diff --git a/.travis.yml b/.travis.yml
index 3ee298947a8..4926ede122b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,10 +13,9 @@ notifications:
 branches:
   only:
     - master
-    - "5.16"
+    - "5.18"
     # enable building tags
     - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
-    - "5.17"
 
 cache:
   yarn: true
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cc753e8cd68..ccc42011219 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,16 @@
-# 5.17.3
-  - Changes from 5.17.2:
-    - Bugfixes:
-      - FIXED: Increased probability of returning alternatives and quality of the ones returned for MLD. [#5048](https://github.com/Project-OSRM/osrm-backend/issues/5048)
+# 5.18.0
+  - Changes from 5.17.0:
+    - Features:
+      - ADDED: `table` plugin now optionally returns `distance` matrix as part of response [#4990](https://github.com/Project-OSRM/osrm-backend/pull/4990)
+      - ADDED: New optional parameter `annotations` for `table` that accepts `distance`, `duration`, or both `distance,duration` as values [#4990](https://github.com/Project-OSRM/osrm-backend/pull/4990)
+    - Infrastructure:
+      - ADDED: Updated libosmium and added protozero and vtzero libraries [#5037](https://github.com/Project-OSRM/osrm-backend/pull/5037)
+      - CHANGED: Use vtzero library in tile plugin [#4686](https://github.com/Project-OSRM/osrm-backend/pull/4686)
+    - Profile:
+      - ADDED: Bicycle profile now returns classes for ferry and tunnel routes. [#5054](https://github.com/Project-OSRM/osrm-backend/pull/5054)
+      - ADDED: Bicycle profile allows to exclude ferry routes (default to not enabled) [#5054](https://github.com/Project-OSRM/osrm-backend/pull/5054)
 
-# 5.17.2
+# 5.17.1
   - Changes from 5.17.0:
     - Bugfixes:
       - FIXED: Do not combine a segregated edge with a roundabout [#5039](https://github.com/Project-OSRM/osrm-backend/issues/5039)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3e6e40828d3..e1767b961d9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -167,7 +167,7 @@ add_executable(osrm-customize src/tools/customize.cpp)
 add_executable(osrm-contract src/tools/contract.cpp)
 add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
 add_executable(osrm-datastore src/tools/store.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm src/osrm/osrm.cpp $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL> )
+add_library(osrm src/osrm/osrm.cpp $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 add_library(osrm_contract src/osrm/contractor.cpp $<TARGET_OBJECTS:CONTRACTOR> $<TARGET_OBJECTS:UTIL>)
 add_library(osrm_extract src/osrm/extractor.cpp $<TARGET_OBJECTS:EXTRACTOR> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 add_library(osrm_guidance $<TARGET_OBJECTS:GUIDANCE> $<TARGET_OBJECTS:UTIL>)
@@ -416,11 +416,30 @@ if(UNIX AND NOT APPLE)
   set(MAYBE_RT_LIBRARY -lrt)
 endif()
 
-# Disallow deprecated protozero APIs
-add_definitions(-DPROTOZERO_STRICT_API)
-
 find_package(Threads REQUIRED)
 
+# Third-party libraries
+set(RAPIDJSON_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rapidjson/include")
+include_directories(SYSTEM ${RAPIDJSON_INCLUDE_DIR})
+
+set(MICROTAR_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src")
+include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
+
+set(MBXGEOM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/geometry.hpp-0.9.2/include")
+include_directories(SYSTEM ${MBXGEOM_INCLUDE_DIR})
+set(CHEAPRULER_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/cheap-ruler-cpp-2.5.4/include")
+include_directories(SYSTEM ${CHEAPRULER_INCLUDE_DIR})
+
+add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
+set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+set(PROTOZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/protozero/include")
+include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
+
+set(VTZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/vtzero/include")
+include_directories(SYSTEM ${VTZERO_INCLUDE_DIR})
+
+
 # if mason is enabled no find_package calls are made
 # to ensure that we are only compiling and linking against
 # fully portable mason packages
@@ -554,14 +573,6 @@ else()
   include_directories(SYSTEM ${OSMIUM_INCLUDE_DIR})
 endif()
 
-set(RAPIDJSON_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/rapidjson/include")
-include_directories(SYSTEM ${RAPIDJSON_INCLUDE_DIR})
-
-set(MICROTAR_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src")
-include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
-add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
-set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
-
 # prefix compilation with ccache by default if available and on clang or gcc
 if(ENABLE_CCACHE AND (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU"))
   find_program(CCACHE_FOUND ccache)
@@ -862,4 +873,4 @@ if (ENABLE_NODE_BINDINGS)
   endforeach()
   add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
   set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
-endif()
+endif()
\ No newline at end of file
diff --git a/README.md b/README.md
index 4afc7836714..4f3540e0f96 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ High performance routing engine written in C++14 designed to run on OpenStreetMa
 The following services are available via HTTP API, C++ library interface and NodeJs wrapper:
 - Nearest - Snaps coordinates to the street network and returns the nearest matches
 - Route - Finds the fastest route between coordinates
-- Table - Computes the duration of the fastest route between all pairs of supplied coordinates
+- Table - Computes the duration or distances of the fastest route between all pairs of supplied coordinates
 - Match - Snaps noisy GPS traces to the road network in the most plausible way
 - Trip - Solves the Traveling Salesman Problem using a greedy heuristic
 - Tile - Generates Mapbox Vector Tiles with internal routing metadata
diff --git a/cucumber.js b/cucumber.js
index b0276ceed45..288e3ba5aea 100644
--- a/cucumber.js
+++ b/cucumber.js
@@ -3,5 +3,5 @@ module.exports = {
     verify: '--strict --tags ~@stress --tags ~@todo --tags ~@mld-only -f progress --require features/support --require features/step_definitions',
     todo: '--strict --tags @todo --require features/support --require features/step_definitions',
     all: '--strict --require features/support --require features/step_definitions',
-    mld: '--strict --tags ~@stress --tags ~@todo --require features/support --require features/step_definitions -f progress'
+    mld: '--strict --tags ~@stress --tags ~@todo --tags ~@ch --require features/support --require features/step_definitions -f progress'
 };
diff --git a/docs/http.md b/docs/http.md
index b14b0a341db..3cb2b811bd6 100644
--- a/docs/http.md
+++ b/docs/http.md
@@ -222,13 +222,13 @@ curl 'http://router.project-osrm.org/route/v1/driving/13.388860,52.517037;13.397
 
 ### Table service
 
-Computes the duration of the fastest route between all pairs of supplied coordinates.
+Computes the duration of the fastest route between all pairs of supplied coordinates. Returns the durations or distances or both between the coordinate pairs. Note that the distances are not the shortest distance between two coordinates, but rather the distances of the fastest routes. Duration is in seconds and distances is in meters.
 
 ```endpoint
-GET /table/v1/{profile}/{coordinates}?{sources}=[{elem}...];&destinations=[{elem}...]
+GET /table/v1/{profile}/{coordinates}?{sources}=[{elem}...];&{destinations}=[{elem}...]&annotations={duration|distance|duration,distance}
 ```
 
-**Coordinates**
+**Options**
 
 In addition to the [general options](#general-options) the following options are supported for this service:
 
@@ -236,6 +236,8 @@ In addition to the [general options](#general-options) the following options are
 |------------|--------------------------------------------------|---------------------------------------------|
 |sources     |`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as source.     |
 |destinations|`{index};{index}[;{index} ...]` or `all` (default)|Use location with given index as destination.|
+|annotations |`duration` (default), `distance`, or `duration,distance`|Return the requested table or tables in response. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
+|
 
 Unlike other array encoded options, the length of `sources` and `destinations` can be **smaller or equal**
 to number of input locations;
@@ -253,14 +255,23 @@ sources=0;5;7&destinations=5;1;4;2;3;6
 #### Example Request
 
 ```curl
-# Returns a 3x3 matrix:
+# Returns a 3x3 duration matrix:
 curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219'
 
-# Returns a 1x3 matrix
+# Returns a 1x3 duration matrix
 curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?sources=0'
 
-# Returns a asymmetric 3x2 matrix with from the polyline encoded locations `qikdcB}~dpXkkHz`:
+# Returns a asymmetric 3x2 duration matrix with from the polyline encoded locations `qikdcB}~dpXkkHz`:
 curl 'http://router.project-osrm.org/table/v1/driving/polyline(egs_Iq_aqAppHzbHulFzeMe`EuvKpnCglA)?sources=0;1;3&destinations=2;4'
+
+# Returns a 3x3 duration matrix:
+curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?annotations=duration'
+
+# Returns a 3x3 distance matrix for CH:
+curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?annotations=distance'
+
+# Returns a 3x3 duration matrix and a 3x3 distance matrix for CH:
+curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397634,52.529407;13.428555,52.523219?annotations=distance,duration'
 ```
 
 **Response**
@@ -268,17 +279,115 @@ curl 'http://router.project-osrm.org/table/v1/driving/polyline(egs_Iq_aqAppHzbHu
 - `code` if the request was successful `Ok` otherwise see the service dependent and general status codes.
 - `durations` array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from
   the i-th waypoint to the j-th waypoint. Values are given in seconds. Can be `null` if no route between `i` and `j` can be found.
+- `distances` array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel distance from
+  the i-th waypoint to the j-th waypoint. Values are given in meters. Can be `null` if no route between `i` and `j` can be found. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
 - `sources` array of `Waypoint` objects describing all sources in order
 - `destinations` array of `Waypoint` objects describing all destinations in order
 
 In case of error the following `code`s are supported in addition to the general ones:
 
-| Type              | Description     |
-|-------------------|-----------------|
+| Type             | Description     |
+|------------------|-----------------|
 | `NoTable`        | No route found. |
+| `NotImplemented`  | This request is not supported |
 
 All other properties might be undefined.
 
+#### Example Response
+
+```json
+{
+  "sources": [
+    {
+      "location": [
+        13.3888,
+        52.517033
+      ],
+      "hint": "PAMAgEVJAoAUAAAAIAAAAAcAAAAAAAAArss0Qa7LNEHiVIRA4lSEQAoAAAAQAAAABAAAAAAAAADMAAAAAEzMAKlYIQM8TMwArVghAwEA3wps52D3",
+      "name": "Friedrichstraße"
+    },
+    {
+      "location": [
+        13.397631,
+        52.529432
+      ],
+      "hint": "WIQBgL6mAoAEAAAABgAAAAAAAAA7AAAAhU6PQHvHj0IAAAAAQbyYQgQAAAAGAAAAAAAAADsAAADMAAAAf27MABiJIQOCbswA_4ghAwAAXwVs52D3",
+      "name": "Torstraße"
+    },
+    {
+      "location": [
+        13.428554,
+        52.523239
+      ],
+      "hint": "7UcAgP___38fAAAAUQAAACYAAABTAAAAhSQKQrXq5kKRbiZCWJo_Qx8AAABRAAAAJgAAAFMAAADMAAAASufMAOdwIQNL58wA03AhAwMAvxBs52D3",
+      "name": "Platz der Vereinten Nationen"
+    }
+  ],
+  "durations": [
+    [
+      0,
+      192.6,
+      382.8
+    ],
+    [
+      199,
+      0,
+      283.9
+    ],
+    [
+      344.7,
+      222.3,
+      0
+    ]
+  ],
+  "destinations": [
+    {
+      "location": [
+        13.3888,
+        52.517033
+      ],
+      "hint": "PAMAgEVJAoAUAAAAIAAAAAcAAAAAAAAArss0Qa7LNEHiVIRA4lSEQAoAAAAQAAAABAAAAAAAAADMAAAAAEzMAKlYIQM8TMwArVghAwEA3wps52D3",
+      "name": "Friedrichstraße"
+    },
+    {
+      "location": [
+        13.397631,
+        52.529432
+      ],
+      "hint": "WIQBgL6mAoAEAAAABgAAAAAAAAA7AAAAhU6PQHvHj0IAAAAAQbyYQgQAAAAGAAAAAAAAADsAAADMAAAAf27MABiJIQOCbswA_4ghAwAAXwVs52D3",
+      "name": "Torstraße"
+    },
+    {
+      "location": [
+        13.428554,
+        52.523239
+      ],
+      "hint": "7UcAgP___38fAAAAUQAAACYAAABTAAAAhSQKQrXq5kKRbiZCWJo_Qx8AAABRAAAAJgAAAFMAAADMAAAASufMAOdwIQNL58wA03AhAwMAvxBs52D3",
+      "name": "Platz der Vereinten Nationen"
+    }
+  ],
+  "code": "Ok",
+  "distances": [
+    [
+      0,
+      1886.89,
+      3791.3
+    ],
+    [
+      1824,
+      0,
+      2838.09
+    ],
+    [
+      3275.36,
+      2361.73,
+      0
+    ]
+  ]
+}
+```
+
+
 ### Match service
 
 Map matching matches/snaps given GPS points to the road network in the most plausible way.
diff --git a/docs/nodejs/api.md b/docs/nodejs/api.md
index eec9ab67de4..01ef653cb43 100644
--- a/docs/nodejs/api.md
+++ b/docs/nodejs/api.md
@@ -110,8 +110,8 @@ Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refer
 
 ### table
 
-Computes duration tables for the given locations. Allows for both symmetric and asymmetric
-tables.
+Computes duration table for the given locations. Allows for both symmetric and asymmetric
+tables. Optionally returns distance table.
 
 **Parameters**
 
diff --git a/docs/profiles.md b/docs/profiles.md
index c539d5121e8..248e9cb526c 100644
--- a/docs/profiles.md
+++ b/docs/profiles.md
@@ -68,7 +68,7 @@ If you want to prioritize certain streets, increase the rate on these.
 
 ## Elements
 ### api_version
-A profile should set `api_version` at the top of your profile. This is done to ensure that older profiles are still supported when the api changes. If `api_version` is not defined, 0 will be assumed. The current api version is 2.
+A profile should set `api_version` at the top of your profile. This is done to ensure that older profiles are still supported when the api changes. If `api_version` is not defined, 0 will be assumed. The current api version is 4.
 
 ### Library files
 The folder [profiles/lib/](../profiles/lib/) contains LUA library files for handling many common processing tasks.
@@ -224,8 +224,8 @@ source_highway_turn_classification | Read          | Integer                   |
 source_access_turn_classification  | Read          | Integer                   | Classification based on access tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
 source_speed                       | Read          | Integer                   | Speed on this source road in km/h
 source_priority_class              | Read          | Enum                      | The type of road priority class of the source. Defined in `include/extractor/guidance/road_classification.hpp`
-target_restricted                  | Read          | Boolean                   | Is it from a restricted access road? (See definition in `process_way`)
-target_mode                        | Read          | Enum                      | Travel mode before the turn. Defined in `include/extractor/travel_mode.hpp`
+target_restricted                  | Read          | Boolean                   | Is the target a restricted access road? (See definition in `process_way`)
+target_mode                        | Read          | Enum                      | Travel mode after the turn. Defined in `include/extractor/travel_mode.hpp`
 target_is_motorway                 | Read          | Boolean                   | Is the target road a motorway?
 target_is_link                     | Read          | Boolean                   | Is the target road a link?
 target_number_of_lanes             | Read          | Integer                   | How many lanes does the target road have? (default when not tagged: 0)
diff --git a/docs/releasing.md b/docs/releasing.md
index efe78dddeed..9a492cd495f 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -43,9 +43,9 @@ We may introduce forward-compatible changes: query parameters and response prope
 
 1. Check out the appropriate release branch `x.y`
 2. Make sure `CHANGELOG.md` is up to date.
-3. Make sure the `package.json` is up to date.
-4. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
-5. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
+3. Make sure the `package.json` on branch `x.y` has been committed.
+4. Make sure all tests are passing (e.g. Travis CI gives you a :green_apple:)
+5. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries. Commit should be one in which the `package.json` version matches the version you want to release.
 6. Use `npm run docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
 7. Push tags and commits: `git push; git push --tags`
 8. On https://github.com/Project-OSRM/osrm-backend/releases press `Draft a new release`,
diff --git a/features/bicycle/classes.feature b/features/bicycle/classes.feature
new file mode 100644
index 00000000000..170abc17283
--- /dev/null
+++ b/features/bicycle/classes.feature
@@ -0,0 +1,92 @@
+@routing @bicycle @mode
+Feature: Bicycle - Mode flag
+    Background:
+        Given the profile "bicycle"
+
+    Scenario: Bicycle - We tag ferries with a class
+        Given the node map
+            """
+            a b
+              c d
+            """
+
+        And the ways
+            | nodes | highway | route |
+            | ab    | primary |       |
+            | bc    |         | ferry |
+            | cd    | primary |       |
+
+        When I route I should get
+            | from | to | route       | turns                                              | classes                  |
+            | a    | d  | ab,bc,cd,cd | depart,notification right,notification left,arrive | [()],[(ferry)],[()],[()] |
+            | d    | a  | cd,bc,ab,ab | depart,notification right,notification left,arrive | [()],[(ferry)],[()],[()] |
+            | c    | a  | bc,ab,ab    | depart,notification left,arrive                    | [(ferry)],[()],[()]      |
+            | d    | b  | cd,bc,bc    | depart,notification right,arrive                   | [()],[(ferry)],[()]      |
+            | a    | c  | ab,bc,bc    | depart,notification right,arrive                   | [()],[(ferry)],[()]      |
+            | b    | d  | bc,cd,cd    | depart,notification left,arrive                    | [(ferry)],[()],[()]      |
+
+    Scenario: Bicycle - We tag tunnel with a class
+        Background:
+            Given a grid size of 200 meters
+
+        Given the node map
+            """
+            a b
+              c d
+            """
+
+        And the ways
+            | nodes | tunnel               |
+            | ab    | no                   |
+            | bc    | yes                  |
+            | cd    |                      |
+
+        When I route I should get
+            | from | to | route       | turns                                      | classes                   |
+            | a    | d  | ab,bc,cd,cd | depart,new name right,new name left,arrive | [()],[(tunnel)],[()],[()] |
+
+    Scenario: Bicycle - We tag classes without intersections
+        Background:
+            Given a grid size of 200 meters
+
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes | name | tunnel |
+            | ab    | road |        |
+            | bc    | road | yes    |
+            | cd    | road |        |
+
+        When I route I should get
+          | from | to | route     | turns         | classes               |
+          | a    | d  | road,road | depart,arrive | [(),(tunnel),()],[()] |
+
+    Scenario: Bicycle - From roundabout on ferry
+        Given the node map
+            """
+                     c
+                  /     \
+            a---b         d---f--h
+                  \     /
+                     e
+                     |
+                     g
+            """
+
+        And the ways
+            | nodes | oneway | highway | junction   | route    |
+            | ab    | yes    | service |            |          |
+            | cb    | yes    | service | roundabout |          |
+            | dc    | yes    | service | roundabout |          |
+            | be    | yes    | service | roundabout |          |
+            | ed    | yes    | service | roundabout |          |
+            | eg    | yes    | service |            |          |
+            | df    |        |         |            | ferry    |
+            | fh    | yes    | service |            |          |
+
+        When I route I should get
+            | from | to | route          | turns                                                                              | classes                          |
+            | a    | h  | ab,df,df,fh,fh | depart,roundabout-exit-2,exit roundabout slight right,notification straight,arrive | [()],[(),()],[(ferry)],[()],[()] |
diff --git a/features/bicycle/exclude.feature b/features/bicycle/exclude.feature
new file mode 100644
index 00000000000..6fdcbfb0737
--- /dev/null
+++ b/features/bicycle/exclude.feature
@@ -0,0 +1,55 @@
+@routing @bicycle @exclude
+Feature: Bicycle - Exclude flags
+    Background:
+        Given the profile file "bicycle" initialized with
+        """
+        profile.excludable = Sequence { Set { 'ferry' } }
+        """
+        Given the node map
+            """
+            a....b~~~~~c...f
+                 :     :
+                 d.....e
+            """
+
+        And the ways
+            | nodes | highway  | route | duration | #                                           |
+            | ab    | service  |       |          | always drivable                             |
+            | bc    |          | ferry | 00:00:01 | not drivable for exclude=ferry, but fast.   |
+            | bd    | service  |       |          | always drivable                             |
+            | de    | service  |       |          | always drivable                             |
+            | ec    | service  |       |          | always drivable                             |
+            | cf    | service  |       |          | always drivable                             |
+
+    Scenario: Bicycle - exclude nothing
+        When I route I should get
+            | from | to | route          |
+            | a    | f  | ab,bc,cf,cf    |
+
+        When I match I should get
+            | trace | matchings | duration |
+            | abcf  | abcf      | 109      |
+
+        When I request a travel time matrix I should get
+            |   | a   | f   |
+            | a | 0   | 109 |
+            | f | 109 | 0   |
+
+    Scenario: Bicycle - exclude ferry
+        Given the query options
+            | exclude  | ferry        |
+
+        When I route I should get
+            | from | to | route             |
+            | a    | f  | ab,bd,de,ec,cf,cf |
+
+        When I match I should get
+            | trace | matchings | duration |
+            | abcf  | abcf      | 301.2    |
+
+        When I request a travel time matrix I should get
+            |   | a          | f        |
+            | a | 0          | 301 +- 1 |
+            | f | 301.2 +- 1 | 0        |
+
+
diff --git a/features/guidance/obvious-turn-discovery.feature b/features/guidance/obvious-turn-discovery.feature
index 414894e7cbb..fd846aceff2 100644
--- a/features/guidance/obvious-turn-discovery.feature
+++ b/features/guidance/obvious-turn-discovery.feature
@@ -1209,3 +1209,33 @@ Feature: Simple Turns
         | a    | c  | knob,knob      | depart,arrive           |
         | d    | e  | soph,soph      | depart,arrive           |
         | d    | a  | soph,knob,knob | depart,turn left,arrive |
+
+
+  # https://www.openstreetmap.org/node/30797565
+  Scenario: No turn instruction when turning from unnamed onto unnamed
+    Given the node map
+      """
+      a
+      |
+      |
+      |
+      |
+      b----------------c
+      |
+      |
+      |
+      |
+      |
+      |
+      d
+      """
+
+    And the ways
+      | nodes | highway    | name | ref   |
+      | ab    | trunk_link |      |       |
+      | db    | secondary  |      | L 460 |
+      | bc    | secondary  |      |       |
+
+    When I route I should get
+      | from | to | route | turns                    |
+      | d    | c  | ,,    | depart,turn right,arrive |
diff --git a/features/step_definitions/distance_matrix.js b/features/step_definitions/distance_matrix.js
index aab1f606458..fde80679f5f 100644
--- a/features/step_definitions/distance_matrix.js
+++ b/features/step_definitions/distance_matrix.js
@@ -1,74 +1,88 @@
 var util = require('util');
 
 module.exports = function () {
-    this.When(/^I request a travel time matrix I should get$/, (table, callback) => {
-        var NO_ROUTE = 2147483647;    // MAX_INT
+    const durationsRegex = new RegExp(/^I request a travel time matrix I should get$/);
+    const distancesRegex = new RegExp(/^I request a travel distance matrix I should get$/);
 
-        var tableRows = table.raw();
+    const DURATIONS_NO_ROUTE = 2147483647;     // MAX_INT
+    const DISTANCES_NO_ROUTE = 3.40282e+38;    // MAX_FLOAT
 
-        if (tableRows[0][0] !== '') throw new Error('*** Top-left cell of matrix table must be empty');
+    this.When(durationsRegex, function(table, callback) {tableParse.call(this, table, DURATIONS_NO_ROUTE, 'durations', callback);}.bind(this));
+    this.When(distancesRegex, function(table, callback) {tableParse.call(this, table, DISTANCES_NO_ROUTE, 'distances', callback);}.bind(this));
+};
 
-        var waypoints = [],
-            columnHeaders = tableRows[0].slice(1),
-            rowHeaders = tableRows.map((h) => h[0]).slice(1),
-            symmetric = columnHeaders.length == rowHeaders.length && columnHeaders.every((ele, i) => ele === rowHeaders[i]);
+const durationsParse = function(v) { return isNaN(parseInt(v)); };
+const distancesParse = function(v) { return isNaN(parseFloat(v)); };
 
-        if (symmetric) {
-            columnHeaders.forEach((nodeName) => {
-                var node = this.findNodeByName(nodeName);
-                if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
-                waypoints.push({ coord: node, type: 'loc' });
-            });
-        } else {
-            columnHeaders.forEach((nodeName) => {
-                var node = this.findNodeByName(nodeName);
-                if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
-                waypoints.push({ coord: node, type: 'dst' });
-            });
-            rowHeaders.forEach((nodeName) => {
-                var node = this.findNodeByName(nodeName);
-                if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
-                waypoints.push({ coord: node, type: 'src' });
+function tableParse(table, noRoute, annotation, callback) {
+
+    const parse = annotation == 'distances' ? distancesParse : durationsParse;
+    const params = this.queryParams;
+    params.annotations = annotation == 'distances' ? 'distance' : 'duration';
+
+    var tableRows = table.raw();
+
+    if (tableRows[0][0] !== '') throw new Error('*** Top-left cell of matrix table must be empty');
+
+    var waypoints = [],
+        columnHeaders = tableRows[0].slice(1),
+        rowHeaders = tableRows.map((h) => h[0]).slice(1),
+        symmetric = columnHeaders.length == rowHeaders.length && columnHeaders.every((ele, i) => ele === rowHeaders[i]);
+
+    if (symmetric) {
+        columnHeaders.forEach((nodeName) => {
+            var node = this.findNodeByName(nodeName);
+            if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
+            waypoints.push({ coord: node, type: 'loc' });
+        });
+    } else {
+        columnHeaders.forEach((nodeName) => {
+            var node = this.findNodeByName(nodeName);
+            if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
+            waypoints.push({ coord: node, type: 'dst' });
+        });
+        rowHeaders.forEach((nodeName) => {
+            var node = this.findNodeByName(nodeName);
+            if (!node) throw new Error(util.format('*** unknown node "%s"', nodeName));
+            waypoints.push({ coord: node, type: 'src' });
+        });
+    }
+
+    var actual = [];
+    actual.push(table.headers);
+
+    this.reprocessAndLoadData((e) => {
+        if (e) return callback(e);
+        // compute matrix
+
+        this.requestTable(waypoints, params, (err, response) => {
+            if (err) return callback(err);
+            if (!response.body.length) return callback(new Error('Invalid response body'));
+
+            var json = JSON.parse(response.body);
+
+            var result = json[annotation].map(row => {
+                var hashes = {};
+                row.forEach((v, i) => { hashes[tableRows[0][i+1]] = parse(v) ? '' : v; });
+                return hashes;
             });
-        }
-
-        var actual = [];
-        actual.push(table.headers);
-
-        this.reprocessAndLoadData((e) => {
-            if (e) return callback(e);
-            // compute matrix
-            var params = this.queryParams;
-
-            this.requestTable(waypoints, params, (err, response) => {
-                if (err) return callback(err);
-                if (!response.body.length) return callback(new Error('Invalid response body'));
-
-                var json = JSON.parse(response.body);
-
-                var result = json['durations'].map(row => {
-                    var hashes = {};
-                    row.forEach((v, i) => { hashes[tableRows[0][i+1]] = isNaN(parseInt(v)) ? '' : v; });
-                    return hashes;
-                });
-
-                var testRow = (row, ri, cb) => {
-                    for (var k in result[ri]) {
-                        if (this.FuzzyMatch.match(result[ri][k], row[k])) {
-                            result[ri][k] = row[k];
-                        } else if (row[k] === '' && result[ri][k] === NO_ROUTE) {
-                            result[ri][k] = '';
-                        } else {
-                            result[ri][k] = result[ri][k].toString();
-                        }
+
+            var testRow = (row, ri, cb) => {
+                for (var k in result[ri]) {
+                    if (this.FuzzyMatch.match(result[ri][k], row[k])) {
+                        result[ri][k] = row[k];
+                    } else if (row[k] === '' && result[ri][k] === noRoute) {
+                        result[ri][k] = '';
+                    } else {
+                        result[ri][k] = result[ri][k].toString();
                     }
+                }
 
-                    result[ri][''] = row[''];
-                    cb(null, result[ri]);
-                };
+                result[ri][''] = row[''];
+                cb(null, result[ri]);
+            };
 
-                this.processRowsAndDiff(table, testRow, callback);
-            });
+            this.processRowsAndDiff(table, testRow, callback);
         });
     });
-};
+}
diff --git a/features/support/data_classes.js b/features/support/data_classes.js
index a383540d6e0..e276f20edb5 100644
--- a/features/support/data_classes.js
+++ b/features/support/data_classes.js
@@ -21,7 +21,8 @@ module.exports = {
                 matchRe = want.match(/^\/(.*)\/$/),
                 // we use this for matching before/after bearing
                 matchBearingListAbs = want.match(/^((\d+)->(\d+))(,(\d+)->(\d+))*\s+\+\-(.+)$/),
-                matchIntersectionListAbs = want.match(/^(((((true|false):\d+)\s{0,1})+,{0,1})+;{0,1})+\s+\+\-(.+)$/);
+                matchIntersectionListAbs = want.match(/^(((((true|false):\d+)\s{0,1})+,{0,1})+;{0,1})+\s+\+\-(.+)$/),
+                matchRangeNumbers = want.match(/\d+\+\-\d+/);
 
             function inRange(margin, got, want) {
                 var fromR = parseFloat(want) - margin,
@@ -105,6 +106,11 @@ module.exports = {
                 return inRange(margin, got, matchAbs[1]);
             } else if (matchRe) {               // regex: /a,b,.*/
                 return got.match(matchRe[1]);
+            } else if (matchRangeNumbers) {
+                let real_want_and_margin = want.split('+-'),
+                    margin = parseFloat(real_want_and_margin[1].trim()),
+                    real_want = parseFloat(real_want_and_margin[0].trim());
+                return inRange(margin, got, real_want);
             } else {
                 return false;
             }
diff --git a/features/support/hooks.js b/features/support/hooks.js
index e58b34bfa22..01c2e6e8921 100644
--- a/features/support/hooks.js
+++ b/features/support/hooks.js
@@ -51,7 +51,7 @@ module.exports = function () {
             .defer(rimraf, this.scenarioLogFile)
             .awaitAll(callback);
         // uncomment to get path to logfile
-        // console.log("  Writing logging output to " + this.scenarioLogFile)
+        // console.log('  Writing logging output to ' + this.scenarioLogFile);
     });
 
     this.After((scenario, callback) => {
diff --git a/features/testbot/distance.feature b/features/testbot/distance.feature
index 8500c1df13a..1b76f45a653 100644
--- a/features/testbot/distance.feature
+++ b/features/testbot/distance.feature
@@ -226,3 +226,22 @@ Feature: Distance calculation
             | x    | v  | xv,xv | 424m +-1 |
             | x    | w  | xw,xw | 360m +-1 |
             | x    | y  | xy,xy | 316m +-1 |
+
+
+    # Check rounding errors
+    Scenario: Distances Long distances
+        Given a grid size of 1000 meters
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes    |
+            | abcd |
+
+        When I route I should get
+            | from | to | distance  |
+            | a    | b  | 1000m +-3 |
+            | a    | c  | 2000m +-3 |
+            | a    | d  | 3000m +-3 |
diff --git a/features/testbot/distance_matrix.feature b/features/testbot/distance_matrix.feature
index 18b400514ef..d97f50924ee 100644
--- a/features/testbot/distance_matrix.feature
+++ b/features/testbot/distance_matrix.feature
@@ -1,14 +1,12 @@
 @matrix @testbot
 Feature: Basic Distance Matrix
-# note that results are travel time, specified in 1/10th of seconds
-# since testbot uses a default speed of 100m/10s, the result matches
-# the number of meters as long as the way type is the default 'primary'
+# note that results of travel distance are in metres
 
     Background:
         Given the profile "testbot"
         And the partition extra arguments "--small-component-size 1 --max-cell-sizes 2,4,8,16"
 
-    Scenario: Testbot - Travel time matrix of minimal network
+    Scenario: Testbot - Travel distance matrix of minimal network
         Given the node map
             """
             a b
@@ -18,57 +16,129 @@ Feature: Basic Distance Matrix
             | nodes |
             | ab    |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  |
-            | a | 0  | 10 |
-            | b | 10 | 0  |
+        When I request a travel distance matrix I should get
+            |   | a      | b      |
+            | a | 0      | 100+-1 |
+            | b | 100+-1 | 0      |
+
+    Scenario: Testbot - Travel distance matrix of minimal network with toll exclude
+        Given the query options
+            | exclude  | toll        |
 
-    Scenario: Testbot - Travel time matrix with different way speeds
         Given the node map
             """
-            a b c d
+            a b
+            c d
             """
 
         And the ways
-            | nodes | highway   |
-            | ab    | primary   |
-            | bc    | secondary |
-            | cd    | tertiary  |
+            | nodes | highway  | toll | #                                                       |
+            | ab    | motorway |      | not drivable for exclude=motorway                       |
+            | cd    | primary  |      | always drivable                                         |
+            | ac    | primary  | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+            | bd    | motorway | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | c      | d      |
+            | a | 0      | 100+-1 |        |        |
+            | b | 100+-1 | 0      |        |        |
+            | c |        |        | 0      | 100+-1 |
+            | d |        |        | 100+-1 | 0      |
+
+    Scenario: Testbot - Travel distance matrix of minimal network with motorway exclude
+        Given the query options
+            | exclude  | motorway  |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  | c  | d  |
-            | a | 0  | 10 | 30 | 60 |
-            | b | 10 | 0  | 20 | 50 |
-            | c | 30 | 20 | 0  | 30 |
-            | d | 60 | 50 | 30 | 0  |
-
-        When I request a travel time matrix I should get
-            |   | a  | b  | c  | d  |
-            | a | 0  | 10 | 30 | 60 |
-
-        When I request a travel time matrix I should get
-            |   |  a |
-            | a |  0 |
-            | b | 10 |
-            | c | 30 |
-            | d | 60 |
-
-    Scenario: Testbot - Travel time matrix with fuzzy match
         Given the node map
             """
             a b
+            c d
             """
 
         And the ways
-            | nodes |
-            | ab    |
+            | nodes | highway     | #                                 |
+            | ab    | motorway    | not drivable for exclude=motorway |
+            | cd    | residential |                                   |
+            | ac    | residential |                                   |
+            | bd    | residential |                                   |
+
+        When I request a travel distance matrix I should get
+            |   | a | b      | c      | d      |
+            | a | 0 | 300+-2 | 100+-2 | 200+-2 |
+
+    Scenario: Testbot - Travel distance matrix of minimal network disconnected motorway exclude
+        Given the query options
+            | exclude  | motorway  |
+        And the extract extra arguments "--small-component-size 4"
+
+        Given the node map
+            """
+            ab                  efgh
+            cd
+            """
+
+        And the ways
+            | nodes | highway     | #                                 |
+            | be    | motorway    | not drivable for exclude=motorway |
+            | abcd  | residential |                                   |
+            | efgh  | residential |                                   |
+
+        When I request a travel distance matrix I should get
+            |   | a | b     | e |
+            | a | 0 | 50+-1 |   |
+
+    Scenario: Testbot - Travel distance matrix of minimal network with motorway and toll excludes
+        Given the query options
+            | exclude  | motorway,toll  |
+
+        Given the node map
+            """
+            a b          e f
+            c d          g h
+            """
+
+        And the ways
+            | nodes | highway     | toll | #                                 |
+            | be    | motorway    |      | not drivable for exclude=motorway |
+            | dg    | primary     | yes  | not drivable for exclude=toll     |
+            | abcd  | residential |      |                                   |
+            | efgh  | residential |      |                                   |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  |
-            | a | 0  | 10 |
-            | b | 10 | 0  |
+        When I request a travel distance matrix I should get
+            |   | a | b      | e | g |
+            | a | 0 | 100+-1 |   |   |
+
+    Scenario: Testbot - Travel distance matrix with different way speeds
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes | highway   |
+            | ab    | primary   |
+            | bc    | secondary |
+            | cd    | tertiary  |
 
-    Scenario: Testbot - Travel time matrix of small grid
+        When I request a travel distance matrix I should get
+            |   | a      | b      | c      | d      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | c | 200+-1 | 100+-1 | 0      | 100+-1 |
+            | d | 300+-1 | 200+-1 | 100+-1 | 0     |
+
+        When I request a travel distance matrix I should get
+            |   | a | b      | c      | d      |
+            | a | 0 | 100+-1 | 200+-1 | 300+-1 |
+
+        When I request a travel distance matrix I should get
+            |   | a      |
+            | a | 0      |
+            | b | 100+-1 |
+            | c | 200+-1 |
+            | d | 300+-1 |
+
+    Scenario: Testbot - Travel distance matrix of small grid
         Given the node map
             """
             a b c
@@ -83,14 +153,14 @@ Feature: Basic Distance Matrix
             | be    |
             | cf    |
 
-        When I request a travel time matrix I should get
-            |   | a  | b  | e  | f  |
-            | a | 0  | 10 | 20 | 30 |
-            | b | 10 | 0  | 10 | 20 |
-            | e | 20 | 10 | 0  | 10 |
-            | f | 30 | 20 | 10 | 0  |
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
+            | f | 300+-1 | 200+-1 | 100+-1 | 0      |
 
-    Scenario: Testbot - Travel time matrix of network with unroutable parts
+    Scenario: Testbot - Travel distance matrix of network with unroutable parts
         Given the node map
             """
             a b
@@ -100,12 +170,12 @@ Feature: Basic Distance Matrix
             | nodes | oneway |
             | ab    | yes    |
 
-        When I request a travel time matrix I should get
-            |   | a | b  |
-            | a | 0 | 10 |
-            | b |   | 0  |
+        When I request a travel distance matrix I should get
+            |   | a | b      |
+            | a | 0 | 100+-1 |
+            | b |   | 0      |
 
-    Scenario: Testbot - Travel time matrix of network with oneways
+    Scenario: Testbot - Travel distance matrix of network with oneways
         Given the node map
             """
             x a b y
@@ -118,14 +188,14 @@ Feature: Basic Distance Matrix
             | xa    |        |
             | by    |        |
 
-        When I request a travel time matrix I should get
-            |   | x  | y   | d  | e  |
-            | x | 0  | 30  | 40 | 30 |
-            | y | 50 | 0   | 30 | 20 |
-            | d | 20 | 30  | 0  | 30 |
-            | e | 30 | 40  | 10 | 0  |
+        When I request a travel distance matrix I should get
+            |   | x      | y      | d      | e      |
+            | x | 0      | 300+-2 | 400+-2 | 300+-2 |
+            | y | 500+-2 | 0      | 300+-2 | 200+-2 |
+            | d | 200+-2 | 300+-2 | 0      | 300+-2 |
+            | e | 300+-2 | 400+-2 | 100+-2 | 0      |
 
-    Scenario: Testbot - Rectangular travel time matrix
+    Scenario: Testbot - Rectangular travel distance matrix
         Given the node map
             """
             a b c
@@ -140,51 +210,57 @@ Feature: Basic Distance Matrix
             | be    |
             | cf    |
 
-        When I request a travel time matrix I should get
-            |   | a | b  | e  | f  |
-            | a | 0 | 10 | 20 | 30 |
-
-        When I request a travel time matrix I should get
-            |   |  a |
-            | a |  0 |
-            | b | 10 |
-            | e | 20 |
-            | f | 30 |
-
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |  f |
-            | a |  0 | 10 | 20 | 30 |
-            | b | 10 |  0 | 10 | 20 |
-
-        When I request a travel time matrix I should get
-            |   |  a |  b |
-            | a |  0 | 10 |
-            | b | 10 |  0 |
-            | e | 20 | 10 |
-            | f | 30 | 20 |
-
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |  f |
-            | a |  0 | 10 | 20 | 30 |
-            | b | 10 |  0 | 10 | 20 |
-            | e | 20 | 10 |  0 | 10 |
-
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |
-            | a |  0 | 10 | 20 |
-            | b | 10 |  0 | 10 |
-            | e | 20 | 10 |  0 |
-            | f | 30 | 20 | 10 |
-
-        When I request a travel time matrix I should get
-            |   |  a |  b |  e |  f |
-            | a |  0 | 10 | 20 | 30 |
-            | b | 10 |  0 | 10 | 20 |
-            | e | 20 | 10 |  0 | 10 |
-            | f | 30 | 20 | 10 |  0 |
-
-
-     Scenario: Testbot - Travel time 3x2 matrix
+        When I route I should get
+            | from | to | distance  |
+            | e    | a  | 200m +- 1 |
+            | e    | b  | 100m +- 1 |
+            | f    | a  | 300m +- 1 |
+            | f    | b  | 200m +- 1 |
+
+        When I request a travel distance matrix I should get
+            |   | a | b      | e      | f      |
+            | a | 0 | 100+-1 | 200+-1 | 300+-1 |
+
+        When I request a travel distance matrix I should get
+            |   | a      |
+            | a | 0      |
+            | b | 100+-1 |
+            | e | 200+-1 |
+            | f | 300+-1 |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      |
+            | a | 0      | 100+-1 |
+            | b | 100+-1 | 0      |
+            | e | 200+-1 | 100+-1 |
+            | f | 300+-1 | 200+-1 |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      |
+            | a | 0      | 100+-1 | 200+-1 |
+            | b | 100+-1 | 0      | 100+-1 |
+            | e | 200+-1 | 100+-1 | 0      |
+            | f | 300+-1 | 200+-1 | 100+-1 |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | e      | f      |
+            | a | 0      | 100+-1 | 200+-1 | 300+-1 |
+            | b | 100+-1 | 0      | 100+-1 | 200+-1 |
+            | e | 200+-1 | 100+-1 | 0      | 100+-1 |
+            | f | 300+-1 | 200+-1 | 100+-1 | 0      |
+
+     Scenario: Testbot - Travel distance 3x2 matrix
         Given the node map
             """
             a b c
@@ -199,10 +275,11 @@ Feature: Basic Distance Matrix
             | be    |
             | cf    |
 
-        When I request a travel time matrix I should get
-            |   | b  | e  | f  |
-            | a | 10 | 20 | 30 |
-            | b | 0  | 10 | 20 |
+
+        When I request a travel distance matrix I should get
+            |   | b      | e      | f      |
+            | a | 100+-1 | 200+-1 | 300+-1 |
+            | b | 0      | 100+-1 | 200+-1 |
 
     Scenario: Testbot - All coordinates are from same small component
         Given a grid size of 300 meters
@@ -221,10 +298,10 @@ Feature: Basic Distance Matrix
             | da    |
             | fg    |
 
-        When I request a travel time matrix I should get
-            |   | f  | g  |
-            | f | 0  | 30 |
-            | g | 30 |  0 |
+        When I request a travel distance matrix I should get
+            |   | f      | g      |
+            | f | 0      | 300+-2 |
+            | g | 300+-2 | 0      |
 
     Scenario: Testbot - Coordinates are from different small component and snap to big CC
         Given a grid size of 300 meters
@@ -244,14 +321,25 @@ Feature: Basic Distance Matrix
             | fg    |
             | hi    |
 
-        When I request a travel time matrix I should get
-            |   | f  | g  | h  | i  |
-            | f | 0  | 30 | 0  | 30 |
-            | g | 30 |  0 | 30 | 0  |
-            | h | 0  | 30 | 0  | 30 |
-            | i | 30 |  0 | 30 | 0  |
-
-    Scenario: Testbot - Travel time matrix with loops
+        When I route I should get
+            | from | to | distance |
+            | f    | g  | 300m     |
+            | f    | i  | 300m     |
+            | g    | f  | 300m     |
+            | g    | h  | 300m     |
+            | h    | g  | 300m     |
+            | h    | i  | 300m     |
+            | i    | f  | 300m     |
+            | i    | h  | 300m     |
+
+        When I request a travel distance matrix I should get
+            |   | f      | g      | h      | i      |
+            | f | 0      | 300+-2 | 0      | 300+-2 |
+            | g | 300+-2 | 0      | 300+-2 | 0      |
+            | h | 0      | 300+-2 | 0      | 300+-2 |
+            | i | 300+-2 | 0      | 300+-2 | 0      |
+
+    Scenario: Testbot - Travel distance matrix with loops
         Given the node map
             """
             a 1 2 b
@@ -265,14 +353,15 @@ Feature: Basic Distance Matrix
             | cd    | yes |
             | da    | yes |
 
-        When I request a travel time matrix I should get
-            |   | 1      | 2      | 3      | 4  |
-            | 1 | 0      | 10 +-1 | 40 +-1 | 50 +-1 |
-            | 2 | 70 +-1 | 0      | 30 +-1 | 40 +-1 |
-            | 3 | 40 +-1 | 50 +-1 | 0      | 10 +-1 |
-            | 4 | 30 +-1 | 40 +-1 | 70 +-1 | 0  |
+        When I request a travel distance matrix I should get
+            |   | 1      | 2      | 3      | 4      |
+            | 1 | 0      | 100+-1 | 400+-1 | 500+-1 |
+            | 2 | 700+-1 | 0      | 300+-1 | 400+-1 |
+            | 3 | 400+-1 | 500+-1 | 0      | 100+-1 |
+            | 4 | 300+-1 | 400+-1 | 700+-1 | 0      |
+
 
-    Scenario: Testbot - Travel time matrix based on segment durations
+    Scenario: Testbot - Travel distance matrix based on segment durations
         Given the profile file
         """
         local functions = require('testbot')
@@ -301,20 +390,19 @@ Feature: Basic Distance Matrix
           """
 
         And the ways
-          | nodes |
-          | abcd  |
-          | ce    |
-
-        When I request a travel time matrix I should get
-          |   |  a |  b |  c |  d |  e |
-          | a |  0 | 11 | 22 | 33 | 33 |
-          | b | 11 |  0 | 11 | 22 | 22 |
-          | c | 22 | 11 |  0 | 11 | 11 |
-          | d | 33 | 22 | 11 |  0 | 22 |
-          | e | 33 | 22 | 11 | 22 |  0 |
-
-
-    Scenario: Testbot - Travel time matrix for alternative loop paths
+            | nodes |
+            | abcd  |
+            | ce    |
+
+        When I request a travel distance matrix I should get
+            |   | a      | b      | c      | d      | e      |
+            | a | 0      | 100+-2 | 200+-2 | 300+-2 | 400+-2 |
+            | b | 100+-2 | 0      | 100+-2 | 200+-2 | 300+-2 |
+            | c | 200+-2 | 100+-2 | 0      | 100+-2 | 200+-2 |
+            | d | 300+-2 | 200+-2 | 100+-2 | 0      | 300+-2 |
+            | e | 400+-2 | 300+-2 | 200+-2 | 300+-2 | 0      |
+
+    Scenario: Testbot - Travel distance matrix for alternative loop paths
         Given the profile file
         """
         local functions = require('testbot')
@@ -350,62 +438,132 @@ Feature: Basic Distance Matrix
             | dc    | yes    |
             | ca    | yes    |
 
-        When I request a travel time matrix I should get
-          |   |   1 |   2 |   3 |   4 |    5 |   6 |   7 |   8 |
-          | 1 |   0 |  11 |   3 |   2 |    6 |   5 | 8.9 | 7.9 |
-          | 2 |   1 |   0 |   4 |   3 |    7 |   6 | 9.9 | 8.9 |
-          | 3 |   9 |   8 |   0 |  11 |    3 |   2 | 5.9 | 4.9 |
-          | 4 |  10 |   9 |   1 |   0 |    4 |   3 | 6.9 | 5.9 |
-          | 5 |   6 |   5 |   9 |   8 |    0 |  11 | 2.9 | 1.9 |
-          | 6 |   7 |   6 |  10 |   9 |    1 |   0 | 3.9 | 2.9 |
-          | 7 | 3.1 | 2.1 | 6.1 | 5.1 |  9.1 | 8.1 |   0 |  11 |
-          | 8 | 4.1 | 3.1 | 7.1 | 6.1 | 10.1 | 9.1 |   1 | 0   |
-
-
-    Scenario: Testbot - Travel time matrix with ties
-        Given the profile file
-        """
-        local functions = require('testbot')
-        functions.process_segment = function(profile, segment)
-          segment.weight = 1
-          segment.duration = 1
-        end
-        functions.process_turn = function(profile, turn)
-          if turn.angle >= 0 then
-            turn.duration = 16
-          else
-            turn.duration = 4
-          end
-          turn.weight = 0
-        end
-        return functions
-        """
-        And the node map
+        When I request a travel distance matrix I should get
+            |   | 1       | 2       | 3       | 4       | 5       | 6       | 7       | 8       |
+            | 1 | 0       | 1100+-5 | 300+-5  | 200+-5  | 600+-5  | 500+-5  | 900+-5  | 800+-5  |
+            | 2 | 100+-5  | 0       | 400+-5  | 300+-5  | 700+-5  | 600+-5  | 1000+-5 | 900+-5  |
+            | 3 | 900+-5  | 800+-5  | 0       | 1100+-5 | 300+-5  | 200+-5  | 600+-5  | 500+-5  |
+            | 4 | 1000+-5 | 900+-5  | 100+-5  | 0       | 400+-5  | 300+-5  | 700+-5  | 600+-5  |
+            | 5 | 600+-5  | 500+-5  | 900+-5  | 800+-5  | 0       | 1100+-5 | 300+-5  | 200+-5  |
+            | 6 | 700+-5  | 600+-5  | 1000+-5 | 900+-5  | 100+-5  | 0       | 400+-5  | 300+-5  |
+            | 7 | 300+-5  | 200+-5  | 600+-5  | 500+-5  | 900+-5  | 800+-5  | 0       | 1100+-5 |
+            | 8 | 400+-5  | 300+-5  | 700+-5  | 600+-5  | 1000+-5 | 900+-5  | 100+-5  | 0       |
+
+        When I request a travel distance matrix I should get
+            |   | 1       |
+            | 1 | 0       |
+            | 2 | 100+-5  |
+            | 3 | 900+-5  |
+            | 4 | 1000+-5 |
+            | 5 | 600+-5  |
+            | 6 | 700+-5  |
+            | 7 | 300+-5  |
+            | 8 | 400+-5  |
+
+    Scenario: Testbot - Travel distance matrix with ties
+        Given the node map
             """
-            a     b
+            a        b
 
             c     d
             """
 
         And the ways
-          | nodes |
-          | ab    |
-          | ac    |
-          | bd    |
-          | dc    |
+            | nodes |
+            | ab    |
+            | ac    |
+            | bd    |
+            | dc    |
 
+        When I route I should get
+            | from | to | route | distance | time | weight |
+            | a    | c  | ac,ac | 200m     | 20s  |     20 |
 
         When I route I should get
-          | from | to | route | distance | time | weight |
-          | a    | c  | ac,ac | 200m     | 5s   |      5 |
-
-        When I request a travel time matrix I should get
-          |   | a | b | c |  d |
-          | a | 0 | 1 | 5 | 10 |
-
-        When I request a travel time matrix I should get
-          |   |  a |
-          | a |  0 |
-          | b |  1 |
-          | c | 15 |
-          | d | 10 |
+            | from | to | route    | distance  |
+            | a    | b  | ab,ab    | 450m      |
+            | a    | c  | ac,ac    | 200m      |
+            | a    | d  | ac,dc,dc | 500m +- 1 |
+
+        When I request a travel distance matrix I should get
+            |   | a | b      | c      | d      |
+            | a | 0 | 450+-2 | 200+-2 | 500+-2 |
+
+        When I request a travel distance matrix I should get
+            |   | a      |
+            | a | 0      |
+            | b | 450+-2 |
+            | c | 200+-2 |
+            | d | 500+-2 |
+
+        When I request a travel distance matrix I should get
+            |   | a      | c      |
+            | a | 0      | 200+-2 |
+            | c | 200+-2 | 0      |
+
+
+    # Check rounding errors
+    Scenario: Testbot - Long distances in tables
+        Given a grid size of 1000 meters
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes    |
+            | abcd     |
+
+        When I request a travel distance matrix I should get
+            |   | a | b       | c       | d       |
+            | a | 0 | 1000+-3 | 2000+-3 | 3000+-3 |
+
+
+    Scenario: Testbot - OneToMany vs ManyToOne
+        Given the node map
+            """
+            a b
+            c
+            """
+
+        And the ways
+            | nodes  | oneway |
+            | ab     | yes    |
+            | ac     |        |
+            | bc     |        |
+
+        When I request a travel distance matrix I should get
+            |   |   a   | b      |
+            | b | 240.4 | 0      |
+
+        When I request a travel distance matrix I should get
+            |   |   a   |
+            | a |   0   |
+            | b | 240.4 |
+
+    Scenario: Testbot - Varying distances between nodes
+        Given the node map
+            """
+            a b   c      d
+
+            e
+
+
+
+            f
+            """
+
+        And the ways
+            | nodes  | oneway |
+            | feabcd | yes    |
+            | ec     |        |
+            | fd     |        |
+
+        When I request a travel distance matrix I should get
+            |   | a       | b       | c       | d       | e       | f       |
+            | a | 0       | 100+-1  | 300+-1  | 650+-1  | 1930+-1 | 1533+-1 |
+            | b | 760+-1  | 0       | 200+-1  | 550+-1  | 1830+-1 | 1433+-1 |
+            | c | 560+-2  | 660+-2  | 0       | 350+-1  | 1630+-1 | 1233+-1 |
+            | d | 1480+-2 | 1580+-1 | 1780+-1 | 0       | 1280+-1 | 883+-1  |
+            | e | 200+-2  | 300+-2  | 500+-1  | 710+-1  | 0       | 1593+-1 |
+            | f | 597+-1  | 696+-1  | 896+-1  | 1108+-1 | 400+-3  | 0       |
diff --git a/features/testbot/duration_matrix.feature b/features/testbot/duration_matrix.feature
new file mode 100644
index 00000000000..c6977dfabd9
--- /dev/null
+++ b/features/testbot/duration_matrix.feature
@@ -0,0 +1,512 @@
+@matrix @testbot
+Feature: Basic Duration Matrix
+# note that results of travel time are in seconds
+
+    Background:
+        Given the profile "testbot"
+        And the partition extra arguments "--small-component-size 1 --max-cell-sizes 2,4,8,16"
+
+    Scenario: Testbot - Travel time matrix of minimal network
+        Given the node map
+            """
+            a b
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  |
+            | a | 0  | 10 |
+            | b | 10 | 0  |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network with toll exclude
+        Given the query options
+            | exclude  | toll        |
+
+        Given the node map
+            """
+            a b
+            c d
+            """
+
+        And the ways
+            | nodes | highway  | toll | #                                        |
+            | ab    | motorway |      | not drivable for exclude=motorway        |
+            | cd    | primary  |      | always drivable                          |
+            | ac    | motorway | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+            | bd    | motorway | yes  | not drivable for exclude=toll and exclude=motorway,toll |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | c  | d  |
+            | a | 0  | 15 |    |    |
+            | b | 15 | 0  |    |    |
+            | c |    |    | 0  | 10 |
+            | d |    |    | 10 | 0  |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network with motorway exclude
+        Given the query options
+            | exclude  | motorway  |
+
+        Given the node map
+            """
+            a b
+            c d
+            """
+
+        And the ways
+            | nodes | highway     | #                                 |
+            | ab    | motorway    | not drivable for exclude=motorway |
+            | cd    | residential |                                   |
+            | ac    | residential |                                   |
+            | bd    | residential |                                   |
+
+        When I request a travel time matrix I should get
+            |   | a | b  | c  | d  |
+            | a | 0 | 45 | 15 | 30 |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network disconnected motorway exclude
+        Given the query options
+            | exclude  | motorway  |
+
+        Given the node map
+            """
+            ab                  efgh
+            cd
+            """
+
+        And the ways
+            | nodes | highway     | #                                 |
+            | be    | motorway    | not drivable for exclude=motorway |
+            | abcd  | residential |                                   |
+            | efgh  | residential |                                   |
+
+        When I request a travel time matrix I should get
+            |   | a | b   | e |
+            | a | 0 | 7.5 |   |
+
+    @ch
+    Scenario: Testbot - Travel time matrix of minimal network with motorway and toll excludes
+        Given the query options
+            | exclude  | motorway,toll  |
+
+        Given the node map
+            """
+            a b          e f
+            c d          g h
+            """
+
+        And the ways
+            | nodes | highway     | toll | #                                 |
+            | be    | motorway    |      | not drivable for exclude=motorway |
+            | dg    | primary     | yes  | not drivable for exclude=toll     |
+            | abcd  | residential |      |                                   |
+            | efgh  | residential |      |                                   |
+
+        When I request a travel time matrix I should get
+            |   | a | b  | e | g |
+            | a | 0 | 15 |   |   |
+
+    Scenario: Testbot - Travel time matrix with different way speeds
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes | highway   |
+            | ab    | primary   |
+            | bc    | secondary |
+            | cd    | tertiary  |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | c  | d  |
+            | a | 0  | 10 | 30 | 60 |
+            | b | 10 | 0  | 20 | 50 |
+            | c | 30 | 20 | 0  | 30 |
+            | d | 60 | 50 | 30 | 0  |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | c  | d  |
+            | a | 0  | 10 | 30 | 60 |
+
+        When I request a travel time matrix I should get
+            |   |  a |
+            | a |  0 |
+            | b | 10 |
+            | c | 30 |
+            | d | 60 |
+
+
+    Scenario: Testbot - Travel time matrix of small grid
+        Given the node map
+            """
+            a b c
+            d e f
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | def   |
+            | ad    |
+            | be    |
+            | cf    |
+
+        When I request a travel time matrix I should get
+            |   | a  | b  | e  | f  |
+            | a | 0  | 10 | 20 | 30 |
+            | b | 10 | 0  | 10 | 20 |
+            | e | 20 | 10 | 0  | 10 |
+            | f | 30 | 20 | 10 | 0  |
+
+
+    Scenario: Testbot - Travel time matrix of network with unroutable parts
+        Given the node map
+            """
+            a b
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+
+        When I request a travel time matrix I should get
+            |   | a | b  |
+            | a | 0 | 10 |
+            | b |   | 0  |
+
+
+    Scenario: Testbot - Travel time matrix of network with oneways
+        Given the node map
+            """
+            x a b y
+              d e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | abeda | yes    |
+            | xa    |        |
+            | by    |        |
+
+        When I request a travel time matrix I should get
+            |   | x  | y   | d  | e  |
+            | x | 0  | 30  | 40 | 30 |
+            | y | 50 | 0   | 30 | 20 |
+            | d | 20 | 30  | 0  | 30 |
+            | e | 30 | 40  | 10 | 0  |
+
+
+    Scenario: Testbot - Rectangular travel time matrix
+        Given the node map
+            """
+            a b c
+            d e f
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | def   |
+            | ad    |
+            | be    |
+            | cf    |
+
+        When I request a travel time matrix I should get
+            |   | a | b  | e  | f  |
+            | a | 0 | 10 | 20 | 30 |
+
+        When I request a travel time matrix I should get
+            |   |  a |
+            | a |  0 |
+            | b | 10 |
+            | e | 20 |
+            | f | 30 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |  f |
+            | a |  0 | 10 | 20 | 30 |
+            | b | 10 |  0 | 10 | 20 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |
+            | a |  0 | 10 |
+            | b | 10 |  0 |
+            | e | 20 | 10 |
+            | f | 30 | 20 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |  f |
+            | a |  0 | 10 | 20 | 30 |
+            | b | 10 |  0 | 10 | 20 |
+            | e | 20 | 10 |  0 | 10 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |
+            | a |  0 | 10 | 20 |
+            | b | 10 |  0 | 10 |
+            | e | 20 | 10 |  0 |
+            | f | 30 | 20 | 10 |
+
+        When I request a travel time matrix I should get
+            |   |  a |  b |  e |  f |
+            | a |  0 | 10 | 20 | 30 |
+            | b | 10 |  0 | 10 | 20 |
+            | e | 20 | 10 |  0 | 10 |
+            | f | 30 | 20 | 10 |  0 |
+
+     Scenario: Testbot - Travel time 3x2 matrix
+        Given the node map
+            """
+            a b c
+            d e f
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | def   |
+            | ad    |
+            | be    |
+            | cf    |
+
+        When I request a travel time matrix I should get
+            |   | b  | e  | f  |
+            | a | 10 | 20 | 30 |
+            | b | 0  | 10 | 20 |
+
+
+    Scenario: Testbot - All coordinates are from same small component
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the node map
+            """
+            a b   f
+            d e   g
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | be    |
+            | ed    |
+            | da    |
+            | fg    |
+
+        When I request a travel time matrix I should get
+            |   | f  | g  |
+            | f | 0  | 30 |
+            | g | 30 |  0 |
+
+
+    Scenario: Testbot - Coordinates are from different small component and snap to big CC
+        Given a grid size of 300 meters
+        Given the extract extra arguments "--small-component-size 4"
+        Given the node map
+            """
+            a b   f h
+            d e   g i
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | be    |
+            | ed    |
+            | da    |
+            | fg    |
+            | hi    |
+
+        When I request a travel time matrix I should get
+            |   | f  | g  | h  | i  |
+            | f | 0  | 30 | 0  | 30 |
+            | g | 30 |  0 | 30 | 0  |
+            | h | 0  | 30 | 0  | 30 |
+            | i | 30 |  0 | 30 | 0  |
+
+
+    Scenario: Testbot - Travel time matrix with loops
+        Given the node map
+            """
+            a 1 2 b
+            d 4 3 c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes |
+            | bc    | yes |
+            | cd    | yes |
+            | da    | yes |
+
+        When I request a travel time matrix I should get
+            |   | 1      | 2      | 3      | 4      |
+            | 1 | 0      | 10 +-1 | 40 +-1 | 50 +-1 |
+            | 2 | 70 +-1 | 0      | 30 +-1 | 40 +-1 |
+            | 3 | 40 +-1 | 50 +-1 | 0      | 10 +-1 |
+            | 4 | 30 +-1 | 40 +-1 | 70 +-1 | 0      |
+
+
+    Scenario: Testbot - Travel time matrix based on segment durations
+        Given the profile file
+        """
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.traffic_signal_penalty = 0
+          profile.u_turn_penalty = 0
+          return profile
+        end
+
+        functions.process_segment = function(profile, segment)
+          segment.weight = 2
+          segment.duration = 11
+        end
+
+        return functions
+        """
+
+        And the node map
+          """
+          a-b-c-d
+              .
+              e
+          """
+
+        And the ways
+          | nodes |
+          | abcd  |
+          | ce    |
+
+        When I request a travel time matrix I should get
+          |   |  a |  b |  c |  d |  e |
+          | a |  0 | 11 | 22 | 33 | 33 |
+          | b | 11 |  0 | 11 | 22 | 22 |
+          | c | 22 | 11 |  0 | 11 | 11 |
+          | d | 33 | 22 | 11 |  0 | 22 |
+          | e | 33 | 22 | 11 | 22 |  0 |
+
+
+    Scenario: Testbot - Travel time matrix for alternative loop paths
+        Given the profile file
+        """
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.traffic_signal_penalty = 0
+          profile.u_turn_penalty = 0
+          profile.weight_precision = 3
+          return profile
+        end
+
+        functions.process_segment = function(profile, segment)
+          segment.weight = 777
+          segment.duration = 3
+        end
+
+        return functions
+        """
+        And the node map
+            """
+            a 2 1 b
+            7     4
+            8     3
+            c 5 6 d
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bd    | yes    |
+            | dc    | yes    |
+            | ca    | yes    |
+
+        When I request a travel time matrix I should get
+          |   |   1 |   2 |   3 |   4 |    5 |   6 |   7 |   8 |
+          | 1 |   0 |  11 |   3 |   2 |    6 |   5 | 8.9 | 7.9 |
+          | 2 |   1 |   0 |   4 |   3 |    7 |   6 | 9.9 | 8.9 |
+          | 3 |   9 |   8 |   0 |  11 |    3 |   2 | 5.9 | 4.9 |
+          | 4 |  10 |   9 |   1 |   0 |    4 |   3 | 6.9 | 5.9 |
+          | 5 |   6 |   5 |   9 |   8 |    0 |  11 | 2.9 | 1.9 |
+          | 6 |   7 |   6 |  10 |   9 |    1 |   0 | 3.9 | 2.9 |
+          | 7 | 3.1 | 2.1 | 6.1 | 5.1 |  9.1 | 8.1 |   0 |  11 |
+          | 8 | 4.1 | 3.1 | 7.1 | 6.1 | 10.1 | 9.1 |   1 | 0   |
+
+
+    Scenario: Testbot - Travel time matrix with ties
+        Given the profile file
+        """
+        local functions = require('testbot')
+        functions.process_segment = function(profile, segment)
+          segment.weight = 1
+          segment.duration = 1
+        end
+        functions.process_turn = function(profile, turn)
+          if turn.angle >= 0 then
+            turn.duration = 16
+          else
+            turn.duration = 4
+          end
+          turn.weight = 0
+        end
+        return functions
+        """
+        And the node map
+            """
+            a     b
+
+            c     d
+            """
+
+        And the ways
+          | nodes |
+          | ab    |
+          | ac    |
+          | bd    |
+          | dc    |
+
+        When I route I should get
+          | from | to | route | distance | time | weight |
+          | a    | c  | ac,ac | 200m     | 5s   |      5 |
+
+        When I request a travel time matrix I should get
+          |   | a | b | c |  d |
+          | a | 0 | 1 | 5 | 10 |
+
+        When I request a travel time matrix I should get
+          |   |  a |
+          | a |  0 |
+          | b |  1 |
+          | c | 15 |
+          | d | 10 |
+
+    Scenario: Testbot - OneToMany vs ManyToOne
+        Given the node map
+            """
+            a b
+            c
+            """
+
+        And the ways
+            | nodes  | oneway |
+            | ab     | yes    |
+            | ac     |        |
+            | bc     |        |
+
+        When I request a travel time matrix I should get
+            |   |   a  |  b  |
+            | b | 24.1 |  0  |
+
+        When I request a travel time matrix I should get
+            |   |   a   |
+            | a |   0   |
+            | b | 24.1  |
diff --git a/features/testbot/multi_level_routing.feature b/features/testbot/multi_level_routing.feature
index 739faf08887..1fd0ab3999b 100644
--- a/features/testbot/multi_level_routing.feature
+++ b/features/testbot/multi_level_routing.feature
@@ -106,6 +106,40 @@ Feature: Multi level routing
             | l | 144.7 |    60 |
             | o | 124.7 |     0 |
 
+
+        When I request a travel distance matrix I should get
+            |   |       a |       f |       l |         o |
+            | a |    0+-2 | 2287+-2 | 1443+-2 |   1243+-2 |
+            | f | 2284+-2 |    0+-2 | 1241+-2 |   1443+-2 |
+            | l | 1443+-2 | 1244+-2 |    0+-2 |    600+-2 |
+            | o | 1243+-2 | 1444+-2 |  600+-2 |      0+-2 |
+
+        When I request a travel distance matrix I should get
+            |   | a | f          | l          | o        |
+            | a | 0 | 2287.2+-2  | 1443+-2    | 1243+-2  |
+
+        When I request a travel distance matrix I should get
+            |   |         a |
+            | a |         0 |
+            | f | 2284.5+-2 |
+            | l |    1443.1 |
+            | o |      1243 |
+
+        When I request a travel distance matrix I should get
+            |   |    a |      f  |      l  |       o |
+            | a |    0 | 2287+-2 | 1443+-2 | 1243+-2 |
+            | o | 1243 | 1444+-2 |  600+-2 |    0+-2 |
+
+
+        When I request a travel distance matrix I should get
+            |   |         a |        o  |
+            | a |      0+-2 |   1243+-2 |
+            | f |   2284+-2 |   1443+-2 |
+            | l |   1443+-2 |    600+-2 |
+            | o |   1243+-2 |      0+-2 |
+
+
+
     Scenario: Testbot - Multi level routing: horizontal road
         Given the node map
             """
diff --git a/features/testbot/traffic_speeds.feature b/features/testbot/traffic_speeds.feature
index 4e2b4ea2656..f5f2198f354 100644
--- a/features/testbot/traffic_speeds.feature
+++ b/features/testbot/traffic_speeds.feature
@@ -54,7 +54,7 @@ Feature: Traffic - speeds
           | a    | d  | ad,ad       | 27 km/h | 1275.7,0             | 1             |
           | d    | c  | dc,dc       | 36 km/h | 956.8,0              | 0             |
           | g    | b  | fb,fb       | 36 km/h | 164.7,0              | 0             |
-          | a    | g  | ad,df,fb,fb | 30 km/h | 1275.7,487.5,304.7,0 | 1:0:0         |
+          | a    | g  | ad,df,fb,fb | 30 km/h | 1295.7,487.5,304.7,0 | 1:0:0         |
 
 
     Scenario: Weighting based on speed file weights, ETA based on file durations
diff --git a/include/customizer/customizer_config.hpp b/include/customizer/customizer_config.hpp
index f889dc2e666..35ab1a35628 100644
--- a/include/customizer/customizer_config.hpp
+++ b/include/customizer/customizer_config.hpp
@@ -21,7 +21,8 @@ struct CustomizationConfig final : storage::IOConfig
                     ".osrm.partition",
                     ".osrm.cells",
                     ".osrm.ebg_nodes",
-                    ".osrm.properties"},
+                    ".osrm.properties",
+                    ".osrm.enw"},
                    {},
                    {".osrm.cell_metrics", ".osrm.mldgr"}),
           requested_num_threads(0)
diff --git a/include/customizer/edge_based_graph.hpp b/include/customizer/edge_based_graph.hpp
index 10a088dbd9d..8414c594283 100644
--- a/include/customizer/edge_based_graph.hpp
+++ b/include/customizer/edge_based_graph.hpp
@@ -16,28 +16,109 @@ namespace osrm
 namespace customizer
 {
 
-using EdgeBasedGraphEdgeData = partitioner::EdgeBasedGraphEdgeData;
-
-struct MultiLevelEdgeBasedGraph
-    : public partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>
+struct EdgeBasedGraphEdgeData
 {
-    using Base =
-        partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
-    using Base::Base;
+    NodeID turn_id; // ID of the edge based node (node based edge)
 };
 
-struct MultiLevelEdgeBasedGraphView
-    : public partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>
+template <typename EdgeDataT, storage::Ownership Ownership> class MultiLevelGraph;
+
+namespace serialization
 {
-    using Base = partitioner::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
-    using Base::Base;
-};
+template <typename EdgeDataT, storage::Ownership Ownership>
+void read(storage::tar::FileReader &reader,
+          const std::string &name,
+          MultiLevelGraph<EdgeDataT, Ownership> &graph);
+
+template <typename EdgeDataT, storage::Ownership Ownership>
+void write(storage::tar::FileWriter &writer,
+           const std::string &name,
+           const MultiLevelGraph<EdgeDataT, Ownership> &graph);
+}
 
-struct StaticEdgeBasedGraphEdge : MultiLevelEdgeBasedGraph::InputEdge
+template <typename EdgeDataT, storage::Ownership Ownership>
+class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership>
 {
-    using Base = MultiLevelEdgeBasedGraph::InputEdge;
-    using Base::Base;
+  private:
+    using SuperT = partitioner::MultiLevelGraph<EdgeDataT, Ownership>;
+    using PartitionerGraphT = partitioner::MultiLevelGraph<partitioner::EdgeBasedGraphEdgeData,
+                                                           storage::Ownership::Container>;
+    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+
+  public:
+    using NodeArrayEntry = typename SuperT::NodeArrayEntry;
+    using EdgeArrayEntry = typename SuperT::EdgeArrayEntry;
+    using EdgeOffset = typename SuperT::EdgeOffset;
+
+    MultiLevelGraph() = default;
+    MultiLevelGraph(MultiLevelGraph &&) = default;
+    MultiLevelGraph(const MultiLevelGraph &) = default;
+    MultiLevelGraph &operator=(MultiLevelGraph &&) = default;
+    MultiLevelGraph &operator=(const MultiLevelGraph &) = default;
+
+    MultiLevelGraph(PartitionerGraphT &&graph,
+                    Vector<EdgeWeight> node_weights_,
+                    Vector<EdgeDuration> node_durations_)
+        : node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_))
+    {
+        util::ViewOrVector<PartitionerGraphT::EdgeArrayEntry, storage::Ownership::Container>
+            original_edge_array;
+
+        std::tie(SuperT::node_array,
+                 original_edge_array,
+                 SuperT::node_to_edge_offset,
+                 SuperT::connectivity_checksum) = std::move(graph).data();
+
+        SuperT::edge_array.reserve(original_edge_array.size());
+        for (const auto &edge : original_edge_array)
+        {
+            SuperT::edge_array.push_back({edge.target, {edge.data.turn_id}});
+            is_forward_edge.push_back(edge.data.forward);
+            is_backward_edge.push_back(edge.data.backward);
+        }
+    }
+
+    MultiLevelGraph(Vector<NodeArrayEntry> node_array_,
+                    Vector<EdgeArrayEntry> edge_array_,
+                    Vector<EdgeOffset> node_to_edge_offset_,
+                    Vector<EdgeWeight> node_weights_,
+                    Vector<EdgeDuration> node_durations_,
+                    Vector<bool> is_forward_edge_,
+                    Vector<bool> is_backward_edge_)
+        : SuperT(std::move(node_array_), std::move(edge_array_), std::move(node_to_edge_offset_)),
+          node_weights(std::move(node_weights_)), node_durations(std::move(node_durations_)),
+          is_forward_edge(is_forward_edge_), is_backward_edge(is_backward_edge_)
+    {
+    }
+
+    EdgeWeight GetNodeWeight(NodeID node) const { return node_weights[node]; }
+
+    EdgeWeight GetNodeDuration(NodeID node) const { return node_durations[node]; }
+
+    bool IsForwardEdge(EdgeID edge) const { return is_forward_edge[edge]; }
+
+    bool IsBackwardEdge(EdgeID edge) const { return is_backward_edge[edge]; }
+
+    friend void
+    serialization::read<EdgeDataT, Ownership>(storage::tar::FileReader &reader,
+                                              const std::string &name,
+                                              MultiLevelGraph<EdgeDataT, Ownership> &graph);
+    friend void
+    serialization::write<EdgeDataT, Ownership>(storage::tar::FileWriter &writer,
+                                               const std::string &name,
+                                               const MultiLevelGraph<EdgeDataT, Ownership> &graph);
+
+  protected:
+    Vector<EdgeWeight> node_weights;
+    Vector<EdgeDuration> node_durations;
+    Vector<bool> is_forward_edge;
+    Vector<bool> is_backward_edge;
 };
+
+using MultiLevelEdgeBasedGraph =
+    MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
+using MultiLevelEdgeBasedGraphView =
+    MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
 }
 }
 
diff --git a/include/customizer/files.hpp b/include/customizer/files.hpp
index c89b5cb7607..364a2572d23 100644
--- a/include/customizer/files.hpp
+++ b/include/customizer/files.hpp
@@ -73,6 +73,39 @@ writeCellMetrics(const boost::filesystem::path &path,
         }
     }
 }
+
+// reads .osrm.mldgr file
+template <typename MultiLevelGraphT>
+inline void readGraph(const boost::filesystem::path &path,
+                      MultiLevelGraphT &graph,
+                      std::uint32_t &connectivity_checksum)
+{
+    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
+                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
+                  "");
+
+    storage::tar::FileReader reader{path, storage::tar::FileReader::VerifyFingerprint};
+
+    reader.ReadInto("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::read(reader, "/mld/multilevelgraph", graph);
+}
+
+// writes .osrm.mldgr file
+template <typename MultiLevelGraphT>
+inline void writeGraph(const boost::filesystem::path &path,
+                       const MultiLevelGraphT &graph,
+                       const std::uint32_t connectivity_checksum)
+{
+    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
+                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
+                  "");
+
+    storage::tar::FileWriter writer{path, storage::tar::FileWriter::GenerateFingerprint};
+
+    writer.WriteElementCount64("/mld/connectivity_checksum", 1);
+    writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::write(writer, "/mld/multilevelgraph", graph);
+}
 }
 }
 }
diff --git a/include/customizer/serialization.hpp b/include/customizer/serialization.hpp
index 973e2517db4..c5c5fdee28e 100644
--- a/include/customizer/serialization.hpp
+++ b/include/customizer/serialization.hpp
@@ -1,6 +1,8 @@
 #ifndef OSRM_CUSTOMIZER_SERIALIZATION_HPP
 #define OSRM_CUSTOMIZER_SERIALIZATION_HPP
 
+#include "customizer/edge_based_graph.hpp"
+
 #include "partitioner/cell_storage.hpp"
 
 #include "storage/serialization.hpp"
@@ -31,6 +33,34 @@ inline void write(storage::tar::FileWriter &writer,
     storage::serialization::write(writer, name + "/weights", metric.weights);
     storage::serialization::write(writer, name + "/durations", metric.durations);
 }
+
+template <typename EdgeDataT, storage::Ownership Ownership>
+inline void read(storage::tar::FileReader &reader,
+                 const std::string &name,
+                 MultiLevelGraph<EdgeDataT, Ownership> &graph)
+{
+    storage::serialization::read(reader, name + "/node_array", graph.node_array);
+    storage::serialization::read(reader, name + "/node_weights", graph.node_weights);
+    storage::serialization::read(reader, name + "/node_durations", graph.node_durations);
+    storage::serialization::read(reader, name + "/edge_array", graph.edge_array);
+    storage::serialization::read(reader, name + "/is_forward_edge", graph.is_forward_edge);
+    storage::serialization::read(reader, name + "/is_backward_edge", graph.is_backward_edge);
+    storage::serialization::read(reader, name + "/node_to_edge_offset", graph.node_to_edge_offset);
+}
+
+template <typename EdgeDataT, storage::Ownership Ownership>
+inline void write(storage::tar::FileWriter &writer,
+                  const std::string &name,
+                  const MultiLevelGraph<EdgeDataT, Ownership> &graph)
+{
+    storage::serialization::write(writer, name + "/node_array", graph.node_array);
+    storage::serialization::write(writer, name + "/node_weights", graph.node_weights);
+    storage::serialization::write(writer, name + "/node_durations", graph.node_durations);
+    storage::serialization::write(writer, name + "/edge_array", graph.edge_array);
+    storage::serialization::write(writer, name + "/is_forward_edge", graph.is_forward_edge);
+    storage::serialization::write(writer, name + "/is_backward_edge", graph.is_backward_edge);
+    storage::serialization::write(writer, name + "/node_to_edge_offset", graph.node_to_edge_offset);
+}
 }
 }
 }
diff --git a/include/engine/algorithm.hpp b/include/engine/algorithm.hpp
index 8f48b373005..760f78e80a5 100644
--- a/include/engine/algorithm.hpp
+++ b/include/engine/algorithm.hpp
@@ -50,6 +50,9 @@ template <typename AlgorithmT> struct HasMapMatching final : std::false_type
 template <typename AlgorithmT> struct HasManyToManySearch final : std::false_type
 {
 };
+template <typename AlgorithmT> struct SupportsDistanceAnnotationType final : std::false_type
+{
+};
 template <typename AlgorithmT> struct HasGetTileTurns final : std::false_type
 {
 };
@@ -73,6 +76,9 @@ template <> struct HasMapMatching<ch::Algorithm> final : std::true_type
 template <> struct HasManyToManySearch<ch::Algorithm> final : std::true_type
 {
 };
+template <> struct SupportsDistanceAnnotationType<ch::Algorithm> final : std::true_type
+{
+};
 template <> struct HasGetTileTurns<ch::Algorithm> final : std::true_type
 {
 };
@@ -96,6 +102,9 @@ template <> struct HasMapMatching<mld::Algorithm> final : std::true_type
 template <> struct HasManyToManySearch<mld::Algorithm> final : std::true_type
 {
 };
+template <> struct SupportsDistanceAnnotationType<mld::Algorithm> final : std::false_type
+{
+};
 template <> struct HasGetTileTurns<mld::Algorithm> final : std::true_type
 {
 };
diff --git a/include/engine/api/table_api.hpp b/include/engine/api/table_api.hpp
index 2ff667404ab..7f8cb770615 100644
--- a/include/engine/api/table_api.hpp
+++ b/include/engine/api/table_api.hpp
@@ -36,9 +36,10 @@ class TableAPI final : public BaseAPI
     {
     }
 
-    virtual void MakeResponse(const std::vector<EdgeWeight> &durations,
-                              const std::vector<PhantomNode> &phantoms,
-                              util::json::Object &response) const
+    virtual void
+    MakeResponse(const std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>> &tables,
+                 const std::vector<PhantomNode> &phantoms,
+                 util::json::Object &response) const
     {
         auto number_of_sources = parameters.sources.size();
         auto number_of_destinations = parameters.destinations.size();
@@ -64,8 +65,18 @@ class TableAPI final : public BaseAPI
             response.values["destinations"] = MakeWaypoints(phantoms, parameters.destinations);
         }
 
-        response.values["durations"] =
-            MakeTable(durations, number_of_sources, number_of_destinations);
+        if (parameters.annotations & TableParameters::AnnotationsType::Duration)
+        {
+            response.values["durations"] =
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
+        }
+
+        if (parameters.annotations & TableParameters::AnnotationsType::Distance)
+        {
+            response.values["distances"] =
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
+        }
+
         response.values["code"] = "Ok";
     }
 
@@ -97,9 +108,9 @@ class TableAPI final : public BaseAPI
         return json_waypoints;
     }
 
-    virtual util::json::Array MakeTable(const std::vector<EdgeWeight> &values,
-                                        std::size_t number_of_rows,
-                                        std::size_t number_of_columns) const
+    virtual util::json::Array MakeDurationTable(const std::vector<EdgeWeight> &values,
+                                                std::size_t number_of_rows,
+                                                std::size_t number_of_columns) const
     {
         util::json::Array json_table;
         for (const auto row : util::irange<std::size_t>(0UL, number_of_rows))
@@ -116,6 +127,7 @@ class TableAPI final : public BaseAPI
                                {
                                    return util::json::Value(util::json::Null());
                                }
+                               // division by 10 because the duration is in deciseconds (10s)
                                return util::json::Value(util::json::Number(duration / 10.));
                            });
             json_table.values.push_back(std::move(json_row));
@@ -123,6 +135,34 @@ class TableAPI final : public BaseAPI
         return json_table;
     }
 
+    virtual util::json::Array MakeDistanceTable(const std::vector<EdgeDistance> &values,
+                                                std::size_t number_of_rows,
+                                                std::size_t number_of_columns) const
+    {
+        util::json::Array json_table;
+        for (const auto row : util::irange<std::size_t>(0UL, number_of_rows))
+        {
+            util::json::Array json_row;
+            auto row_begin_iterator = values.begin() + (row * number_of_columns);
+            auto row_end_iterator = values.begin() + ((row + 1) * number_of_columns);
+            json_row.values.resize(number_of_columns);
+            std::transform(row_begin_iterator,
+                           row_end_iterator,
+                           json_row.values.begin(),
+                           [](const EdgeDistance distance) {
+                               if (distance == INVALID_EDGE_DISTANCE)
+                               {
+                                   return util::json::Value(util::json::Null());
+                               }
+                               // round to single decimal place
+                               return util::json::Value(
+                                   util::json::Number(std::round(distance * 10) / 10.));
+                           });
+            json_table.values.push_back(std::move(json_row));
+        }
+        return json_table;
+    }
+
     const TableParameters &parameters;
 };
 
diff --git a/include/engine/api/table_parameters.hpp b/include/engine/api/table_parameters.hpp
index 58d936c7347..4f1a496bd6f 100644
--- a/include/engine/api/table_parameters.hpp
+++ b/include/engine/api/table_parameters.hpp
@@ -60,6 +60,16 @@ struct TableParameters : public BaseParameters
     std::vector<std::size_t> sources;
     std::vector<std::size_t> destinations;
 
+    enum class AnnotationsType
+    {
+        None = 0,
+        Duration = 0x01,
+        Distance = 0x02,
+        All = Duration | Distance
+    };
+
+    AnnotationsType annotations = AnnotationsType::Duration;
+
     TableParameters() = default;
     template <typename... Args>
     TableParameters(std::vector<std::size_t> sources_,
@@ -70,6 +80,16 @@ struct TableParameters : public BaseParameters
     {
     }
 
+    template <typename... Args>
+    TableParameters(std::vector<std::size_t> sources_,
+                    std::vector<std::size_t> destinations_,
+                    const AnnotationsType annotations_,
+                    Args... args_)
+        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
+          destinations{std::move(destinations_)}, annotations{annotations_}
+    {
+    }
+
     bool IsValid() const
     {
         if (!BaseParameters::IsValid())
@@ -79,7 +99,7 @@ struct TableParameters : public BaseParameters
         if (coordinates.size() < 2)
             return false;
 
-        // 1/ The user is able to specify duplicates in srcs and dsts, in that case it's her fault
+        // 1/ The user is able to specify duplicates in srcs and dsts, in that case it's their fault
 
         // 2/ len(srcs) and len(dsts) smaller or equal to len(locations)
         if (sources.size() > coordinates.size())
@@ -100,6 +120,26 @@ struct TableParameters : public BaseParameters
         return true;
     }
 };
+inline bool operator&(TableParameters::AnnotationsType lhs, TableParameters::AnnotationsType rhs)
+{
+    return static_cast<bool>(
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(lhs) &
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(rhs));
+}
+
+inline TableParameters::AnnotationsType operator|(TableParameters::AnnotationsType lhs,
+                                                  TableParameters::AnnotationsType rhs)
+{
+    return (TableParameters::AnnotationsType)(
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(lhs) |
+        static_cast<std::underlying_type_t<TableParameters::AnnotationsType>>(rhs));
+}
+
+inline TableParameters::AnnotationsType &operator|=(TableParameters::AnnotationsType &lhs,
+                                                    TableParameters::AnnotationsType rhs)
+{
+    return lhs = lhs | rhs;
+}
 }
 }
 }
diff --git a/include/engine/datafacade/algorithm_datafacade.hpp b/include/engine/datafacade/algorithm_datafacade.hpp
index cdf49c286f5..ef910d4ac22 100644
--- a/include/engine/datafacade/algorithm_datafacade.hpp
+++ b/include/engine/datafacade/algorithm_datafacade.hpp
@@ -2,6 +2,7 @@
 #define OSRM_ENGINE_DATAFACADE_ALGORITHM_DATAFACADE_HPP
 
 #include "contractor/query_edge.hpp"
+#include "customizer/edge_based_graph.hpp"
 #include "extractor/edge_based_edge.hpp"
 #include "engine/algorithm.hpp"
 
@@ -59,7 +60,7 @@ template <> class AlgorithmDataFacade<CH>
 template <> class AlgorithmDataFacade<MLD>
 {
   public:
-    using EdgeData = extractor::EdgeBasedEdge::EdgeData;
+    using EdgeData = customizer::EdgeBasedGraphEdgeData;
     using EdgeRange = util::range<EdgeID>;
 
     // search graph access
@@ -71,12 +72,20 @@ template <> class AlgorithmDataFacade<MLD>
 
     virtual unsigned GetOutDegree(const NodeID n) const = 0;
 
+    virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;
+
+    virtual EdgeWeight GetNodeWeight(const NodeID node) const = 0;
+
+    virtual EdgeWeight GetNodeDuration(const NodeID node) const = 0; // TODO: to be removed
+
+    virtual bool IsForwardEdge(EdgeID edge) const = 0;
+
+    virtual bool IsBackwardEdge(EdgeID edge) const = 0;
+
     virtual NodeID GetTarget(const EdgeID e) const = 0;
 
     virtual const EdgeData &GetEdgeData(const EdgeID e) const = 0;
 
-    virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;
-
     virtual const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const = 0;
 
     virtual const partitioner::CellStorageView &GetCellStorage() const = 0;
diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
index 846a1a04c77..6befce6d08d 100644
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@@ -133,7 +133,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     using RTreeNode = SharedRTree::TreeNode;
 
     extractor::ClassData exclude_mask;
-    std::string m_timestamp;
     extractor::ProfileProperties *m_profile_properties;
     extractor::Datasources *m_datasources;
 
@@ -283,13 +282,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return segment_data.GetReverseDatasources(id);
     }
 
-    TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const override final
+    TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID id) const override final
     {
         BOOST_ASSERT(m_turn_weight_penalties.size() > id);
         return m_turn_weight_penalties[id];
     }
 
-    TurnPenalty GetDurationPenaltyForEdgeID(const unsigned id) const override final
+    TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID id) const override final
     {
         BOOST_ASSERT(m_turn_duration_penalties.size() > id);
         return m_turn_duration_penalties[id];
@@ -622,7 +621,6 @@ class ContiguousInternalMemoryDataFacade<CH>
                                        const std::size_t exclude_index)
         : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
           ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator, metric_name, exclude_index)
-
     {
     }
 };
@@ -684,16 +682,36 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
         return query_graph.GetOutDegree(n);
     }
 
-    NodeID GetTarget(const EdgeID e) const override final { return query_graph.GetTarget(e); }
+    EdgeRange GetAdjacentEdgeRange(const NodeID node) const override final
+    {
+        return query_graph.GetAdjacentEdgeRange(node);
+    }
 
-    const EdgeData &GetEdgeData(const EdgeID e) const override final
+    EdgeWeight GetNodeWeight(const NodeID node) const override final
     {
-        return query_graph.GetEdgeData(e);
+        return query_graph.GetNodeWeight(node);
     }
 
-    EdgeRange GetAdjacentEdgeRange(const NodeID node) const override final
+    EdgeDuration GetNodeDuration(const NodeID node) const override final
     {
-        return query_graph.GetAdjacentEdgeRange(node);
+        return query_graph.GetNodeDuration(node);
+    }
+
+    bool IsForwardEdge(const NodeID node) const override final
+    {
+        return query_graph.IsForwardEdge(node);
+    }
+
+    bool IsBackwardEdge(const NodeID node) const override final
+    {
+        return query_graph.IsBackwardEdge(node);
+    }
+
+    NodeID GetTarget(const EdgeID e) const override final { return query_graph.GetTarget(e); }
+
+    const EdgeData &GetEdgeData(const EdgeID e) const override final
+    {
+        return query_graph.GetEdgeData(e);
     }
 
     EdgeRange GetBorderEdgeRange(const LevelID level, const NodeID node) const override final
@@ -720,7 +738,6 @@ class ContiguousInternalMemoryDataFacade<MLD> final
                                        const std::size_t exclude_index)
         : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
           ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator, metric_name, exclude_index)
-
     {
     }
 };
diff --git a/include/engine/datafacade/datafacade_base.hpp b/include/engine/datafacade/datafacade_base.hpp
index beb71674ee0..091017859b3 100644
--- a/include/engine/datafacade/datafacade_base.hpp
+++ b/include/engine/datafacade/datafacade_base.hpp
@@ -33,7 +33,6 @@
 
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/any_range.hpp>
-
 #include <cstddef>
 
 #include <string>
@@ -87,9 +86,9 @@ class BaseDataFacade
     virtual NodeForwardRange GetUncompressedForwardGeometry(const EdgeID id) const = 0;
     virtual NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const = 0;
 
-    virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const = 0;
+    virtual TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID id) const = 0;
 
-    virtual TurnPenalty GetDurationPenaltyForEdgeID(const unsigned id) const = 0;
+    virtual TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID id) const = 0;
 
     // Gets the weight values for each segment in an uncompressed geometry.
     // Should always be 1 shorter than GetUncompressedGeometry
diff --git a/include/engine/geospatial_query.hpp b/include/engine/geospatial_query.hpp
index b9a709d0cb7..4ecfc8118bd 100644
--- a/include/engine/geospatial_query.hpp
+++ b/include/engine/geospatial_query.hpp
@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <iterator>
 #include <memory>
 #include <vector>
 
@@ -447,6 +448,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         const auto forward_durations = datafacade.GetUncompressedForwardDurations(geometry_id);
         const auto reverse_durations = datafacade.GetUncompressedReverseDurations(geometry_id);
 
+        const auto forward_geometry = datafacade.GetUncompressedForwardGeometry(geometry_id);
+
         const auto forward_weight_offset =
             std::accumulate(forward_weights.begin(),
                             forward_weights.begin() + data.fwd_segment_position,
@@ -457,12 +460,25 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                             forward_durations.begin() + data.fwd_segment_position,
                             EdgeDuration{0});
 
-        EdgeWeight forward_weight = forward_weights[data.fwd_segment_position];
-        EdgeDuration forward_duration = forward_durations[data.fwd_segment_position];
+        EdgeDistance forward_distance_offset = 0;
+        for (auto current = forward_geometry.begin();
+             current < forward_geometry.begin() + data.fwd_segment_position;
+             ++current)
+        {
+            forward_distance_offset += util::coordinate_calculation::fccApproximateDistance(
+                datafacade.GetCoordinateOfNode(*current),
+                datafacade.GetCoordinateOfNode(*std::next(current)));
+        }
 
         BOOST_ASSERT(data.fwd_segment_position <
                      std::distance(forward_durations.begin(), forward_durations.end()));
 
+        EdgeWeight forward_weight = forward_weights[data.fwd_segment_position];
+        EdgeDuration forward_duration = forward_durations[data.fwd_segment_position];
+        EdgeDistance forward_distance = util::coordinate_calculation::fccApproximateDistance(
+            datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position)),
+            point_on_segment);
+
         const auto reverse_weight_offset =
             std::accumulate(reverse_weights.begin(),
                             reverse_weights.end() - data.fwd_segment_position - 1,
@@ -473,10 +489,23 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                             reverse_durations.end() - data.fwd_segment_position - 1,
                             EdgeDuration{0});
 
+        EdgeDistance reverse_distance_offset = 0;
+        for (auto current = forward_geometry.begin();
+             current < forward_geometry.end() - data.fwd_segment_position - 2;
+             ++current)
+        {
+            reverse_distance_offset += util::coordinate_calculation::fccApproximateDistance(
+                datafacade.GetCoordinateOfNode(*current),
+                datafacade.GetCoordinateOfNode(*std::next(current)));
+        }
+
         EdgeWeight reverse_weight =
             reverse_weights[reverse_weights.size() - data.fwd_segment_position - 1];
         EdgeDuration reverse_duration =
             reverse_durations[reverse_durations.size() - data.fwd_segment_position - 1];
+        EdgeDistance reverse_distance = util::coordinate_calculation::fccApproximateDistance(
+            point_on_segment,
+            datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1)));
 
         ratio = std::min(1.0, std::max(0.0, ratio));
         if (data.forward_segment_id.id != SPECIAL_SEGMENTID)
@@ -510,6 +539,10 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                         reverse_weight,
                         forward_weight_offset,
                         reverse_weight_offset,
+                        forward_distance,
+                        reverse_distance,
+                        forward_distance_offset,
+                        reverse_distance_offset,
                         forward_duration,
                         reverse_duration,
                         forward_duration_offset,
diff --git a/include/engine/hint.hpp b/include/engine/hint.hpp
index 7334b673796..3ab69b928e0 100644
--- a/include/engine/hint.hpp
+++ b/include/engine/hint.hpp
@@ -63,8 +63,8 @@ struct Hint
     friend std::ostream &operator<<(std::ostream &, const Hint &);
 };
 
-static_assert(sizeof(Hint) == 64 + 4, "Hint is bigger than expected");
-constexpr std::size_t ENCODED_HINT_SIZE = 92;
+static_assert(sizeof(Hint) == 80 + 4, "Hint is bigger than expected");
+constexpr std::size_t ENCODED_HINT_SIZE = 112;
 static_assert(ENCODED_HINT_SIZE / 4 * 3 >= sizeof(Hint),
               "ENCODED_HINT_SIZE does not match size of Hint");
 }
diff --git a/include/engine/phantom_node.hpp b/include/engine/phantom_node.hpp
index 9357c009e10..3cb0b959369 100644
--- a/include/engine/phantom_node.hpp
+++ b/include/engine/phantom_node.hpp
@@ -47,10 +47,13 @@ struct PhantomNode
         : forward_segment_id{SPECIAL_SEGMENTID, false},
           reverse_segment_id{SPECIAL_SEGMENTID, false}, forward_weight(INVALID_EDGE_WEIGHT),
           reverse_weight(INVALID_EDGE_WEIGHT), forward_weight_offset(0), reverse_weight_offset(0),
+          forward_distance(INVALID_EDGE_DISTANCE), reverse_distance(INVALID_EDGE_DISTANCE),
+          forward_distance_offset(0), reverse_distance_offset(0),
           forward_duration(MAXIMAL_EDGE_DURATION), reverse_duration(MAXIMAL_EDGE_DURATION),
           forward_duration_offset(0), reverse_duration_offset(0), fwd_segment_position(0),
           is_valid_forward_source{false}, is_valid_forward_target{false},
           is_valid_reverse_source{false}, is_valid_reverse_target{false}, bearing(0)
+
     {
     }
 
@@ -78,6 +81,30 @@ struct PhantomNode
         return reverse_duration + reverse_duration_offset;
     }
 
+    // DO THIS FOR DISTANCE
+
+    EdgeDistance GetForwardDistance() const
+    {
+        // .....                  <-- forward_distance
+        //      ....              <-- offset
+        // .........              <-- desired distance
+        //         x              <-- this is PhantomNode.location
+        // 0----1----2----3----4  <-- EdgeBasedGraph Node segments
+        BOOST_ASSERT(forward_segment_id.enabled);
+        return forward_distance + forward_distance_offset;
+    }
+
+    EdgeDistance GetReverseDistance() const
+    {
+        //            ..........  <-- reverse_distance
+        //         ...            <-- offset
+        //         .............  <-- desired distance
+        //         x              <-- this is PhantomNode.location
+        // 0----1----2----3----4  <-- EdgeBasedGraph Node segments
+        BOOST_ASSERT(reverse_segment_id.enabled);
+        return reverse_distance + reverse_distance_offset;
+    }
+
     bool IsBidirected() const { return forward_segment_id.enabled && reverse_segment_id.enabled; }
 
     bool IsValid(const unsigned number_of_nodes) const
@@ -88,6 +115,8 @@ struct PhantomNode
                 (reverse_weight != INVALID_EDGE_WEIGHT)) &&
                ((forward_duration != MAXIMAL_EDGE_DURATION) ||
                 (reverse_duration != MAXIMAL_EDGE_DURATION)) &&
+               ((forward_distance != INVALID_EDGE_DISTANCE) ||
+                (reverse_distance != INVALID_EDGE_DISTANCE)) &&
                (component.id != INVALID_COMPONENTID);
     }
 
@@ -130,6 +159,10 @@ struct PhantomNode
                          EdgeWeight reverse_weight,
                          EdgeWeight forward_weight_offset,
                          EdgeWeight reverse_weight_offset,
+                         EdgeDistance forward_distance,
+                         EdgeDistance reverse_distance,
+                         EdgeDistance forward_distance_offset,
+                         EdgeDistance reverse_distance_offset,
                          EdgeWeight forward_duration,
                          EdgeWeight reverse_duration,
                          EdgeWeight forward_duration_offset,
@@ -144,7 +177,9 @@ struct PhantomNode
         : forward_segment_id{other.forward_segment_id},
           reverse_segment_id{other.reverse_segment_id}, forward_weight{forward_weight},
           reverse_weight{reverse_weight}, forward_weight_offset{forward_weight_offset},
-          reverse_weight_offset{reverse_weight_offset}, forward_duration{forward_duration},
+          reverse_weight_offset{reverse_weight_offset}, forward_distance{forward_distance},
+          reverse_distance{reverse_distance}, forward_distance_offset{forward_distance_offset},
+          reverse_distance_offset{reverse_distance_offset}, forward_duration{forward_duration},
           reverse_duration{reverse_duration}, forward_duration_offset{forward_duration_offset},
           reverse_duration_offset{reverse_duration_offset},
           component{component.id, component.is_tiny}, location{location},
@@ -162,13 +197,17 @@ struct PhantomNode
     EdgeWeight reverse_weight;
     EdgeWeight forward_weight_offset; // TODO: try to remove -> requires path unpacking changes
     EdgeWeight reverse_weight_offset; // TODO: try to remove -> requires path unpacking changes
+    EdgeDistance forward_distance;
+    EdgeDistance reverse_distance;
+    EdgeDistance forward_distance_offset; // TODO: try to remove -> requires path unpacking changes
+    EdgeDistance reverse_distance_offset; // TODO: try to remove -> requires path unpacking changes
     EdgeWeight forward_duration;
     EdgeWeight reverse_duration;
     EdgeWeight forward_duration_offset; // TODO: try to remove -> requires path unpacking changes
     EdgeWeight reverse_duration_offset; // TODO: try to remove -> requires path unpacking changes
     ComponentID component;
 
-    util::Coordinate location;
+    util::Coordinate location; // this is the coordinate of x
     util::Coordinate input_location;
     unsigned short fwd_segment_position;
     // is phantom node valid to be used as source or target
@@ -180,7 +219,7 @@ struct PhantomNode
     unsigned short bearing : 12;
 };
 
-static_assert(sizeof(PhantomNode) == 64, "PhantomNode has more padding then expected");
+static_assert(sizeof(PhantomNode) == 80, "PhantomNode has more padding then expected");
 
 using PhantomNodePair = std::pair<PhantomNode, PhantomNode>;
 
diff --git a/include/engine/routing_algorithms.hpp b/include/engine/routing_algorithms.hpp
index dd8bcc8dde5..aec19f753d3 100644
--- a/include/engine/routing_algorithms.hpp
+++ b/include/engine/routing_algorithms.hpp
@@ -30,10 +30,12 @@ class RoutingAlgorithmsInterface
     virtual InternalRouteResult
     DirectShortestPathSearch(const PhantomNodes &phantom_node_pair) const = 0;
 
-    virtual std::vector<EdgeDuration>
+    virtual std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
     ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
                      const std::vector<std::size_t> &source_indices,
-                     const std::vector<std::size_t> &target_indices) const = 0;
+                     const std::vector<std::size_t> &target_indices,
+                     const bool calculate_distance,
+                     const bool calculate_duration) const = 0;
 
     virtual routing_algorithms::SubMatchingList
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
@@ -53,6 +55,7 @@ class RoutingAlgorithmsInterface
     virtual bool HasDirectShortestPathSearch() const = 0;
     virtual bool HasMapMatching() const = 0;
     virtual bool HasManyToManySearch() const = 0;
+    virtual bool SupportsDistanceAnnotationType() const = 0;
     virtual bool HasGetTileTurns() const = 0;
     virtual bool HasExcludeFlags() const = 0;
     virtual bool IsValid() const = 0;
@@ -81,10 +84,12 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
     InternalRouteResult
     DirectShortestPathSearch(const PhantomNodes &phantom_nodes) const final override;
 
-    std::vector<EdgeDuration>
+    virtual std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
     ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
                      const std::vector<std::size_t> &source_indices,
-                     const std::vector<std::size_t> &target_indices) const final override;
+                     const std::vector<std::size_t> &target_indices,
+                     const bool calculate_distance,
+                     const bool calculate_duration) const final override;
 
     routing_algorithms::SubMatchingList
     MapMatching(const routing_algorithms::CandidateLists &candidates_list,
@@ -124,6 +129,11 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
         return routing_algorithms::HasManyToManySearch<Algorithm>::value;
     }
 
+    bool SupportsDistanceAnnotationType() const final override
+    {
+        return routing_algorithms::SupportsDistanceAnnotationType<Algorithm>::value;
+    }
+
     bool HasGetTileTurns() const final override
     {
         return routing_algorithms::HasGetTileTurns<Algorithm>::value;
@@ -184,10 +194,12 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
 }
 
 template <typename Algorithm>
-std::vector<EdgeDuration> RoutingAlgorithms<Algorithm>::ManyToManySearch(
-    const std::vector<PhantomNode> &phantom_nodes,
-    const std::vector<std::size_t> &_source_indices,
-    const std::vector<std::size_t> &_target_indices) const
+std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
+RoutingAlgorithms<Algorithm>::ManyToManySearch(const std::vector<PhantomNode> &phantom_nodes,
+                                               const std::vector<std::size_t> &_source_indices,
+                                               const std::vector<std::size_t> &_target_indices,
+                                               const bool calculate_distance,
+                                               const bool calculate_duration) const
 {
     BOOST_ASSERT(!phantom_nodes.empty());
 
@@ -205,8 +217,13 @@ std::vector<EdgeDuration> RoutingAlgorithms<Algorithm>::ManyToManySearch(
         std::iota(target_indices.begin(), target_indices.end(), 0);
     }
 
-    return routing_algorithms::manyToManySearch(
-        heaps, *facade, phantom_nodes, std::move(source_indices), std::move(target_indices));
+    return routing_algorithms::manyToManySearch(heaps,
+                                                *facade,
+                                                phantom_nodes,
+                                                std::move(source_indices),
+                                                std::move(target_indices),
+                                                calculate_distance,
+                                                calculate_duration);
 }
 
 template <typename Algorithm>
diff --git a/include/engine/routing_algorithms/many_to_many.hpp b/include/engine/routing_algorithms/many_to_many.hpp
index f4d21884645..281844abd18 100644
--- a/include/engine/routing_algorithms/many_to_many.hpp
+++ b/include/engine/routing_algorithms/many_to_many.hpp
@@ -15,23 +15,43 @@ namespace engine
 {
 namespace routing_algorithms
 {
-
 namespace
 {
 struct NodeBucket
 {
     NodeID middle_node;
-    unsigned column_index; // a column in the weight/duration matrix
+    NodeID parent_node;
+    unsigned column_index : 31; // a column in the weight/duration matrix
+    unsigned from_clique_arc : 1;
     EdgeWeight weight;
     EdgeDuration duration;
 
-    NodeBucket(NodeID middle_node, unsigned column_index, EdgeWeight weight, EdgeDuration duration)
-        : middle_node(middle_node), column_index(column_index), weight(weight), duration(duration)
+    NodeBucket(NodeID middle_node,
+               NodeID parent_node,
+               bool from_clique_arc,
+               unsigned column_index,
+               EdgeWeight weight,
+               EdgeDuration duration)
+        : middle_node(middle_node), parent_node(parent_node), column_index(column_index),
+          from_clique_arc(from_clique_arc), weight(weight), duration(duration)
+    {
+    }
+
+    NodeBucket(NodeID middle_node,
+               NodeID parent_node,
+               unsigned column_index,
+               EdgeWeight weight,
+               EdgeDuration duration)
+        : middle_node(middle_node), parent_node(parent_node), column_index(column_index),
+          from_clique_arc(false), weight(weight), duration(duration)
     {
     }
 
     // partial order comparison
-    bool operator<(const NodeBucket &rhs) const { return middle_node < rhs.middle_node; }
+    bool operator<(const NodeBucket &rhs) const
+    {
+        return std::tie(middle_node, column_index) < std::tie(rhs.middle_node, rhs.column_index);
+    }
 
     // functor for equal_range
     struct Compare
@@ -46,15 +66,36 @@ struct NodeBucket
             return lhs < rhs.middle_node;
         }
     };
+
+    // functor for equal_range
+    struct ColumnCompare
+    {
+        unsigned column_idx;
+
+        ColumnCompare(unsigned column_idx) : column_idx(column_idx){};
+
+        bool operator()(const NodeBucket &lhs, const NodeID &rhs) const // lowerbound
+        {
+            return std::tie(lhs.middle_node, lhs.column_index) < std::tie(rhs, column_idx);
+        }
+
+        bool operator()(const NodeID &lhs, const NodeBucket &rhs) const // upperbound
+        {
+            return std::tie(lhs, column_idx) < std::tie(rhs.middle_node, rhs.column_index);
+        }
+    };
 };
-}
+} // namespace
 
 template <typename Algorithm>
-std::vector<EdgeDuration> manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                                           const DataFacade<Algorithm> &facade,
-                                           const std::vector<PhantomNode> &phantom_nodes,
-                                           const std::vector<std::size_t> &source_indices,
-                                           const std::vector<std::size_t> &target_indices);
+std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
+manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
+                 const DataFacade<Algorithm> &facade,
+                 const std::vector<PhantomNode> &phantom_nodes,
+                 const std::vector<std::size_t> &source_indices,
+                 const std::vector<std::size_t> &target_indices,
+                 const bool calculate_distance,
+                 const bool calculate_duration);
 
 } // namespace routing_algorithms
 } // namespace engine
diff --git a/include/engine/routing_algorithms/routing_base.hpp b/include/engine/routing_algorithms/routing_base.hpp
index 90e5e73e2a8..0c0808a3f49 100644
--- a/include/engine/routing_algorithms/routing_base.hpp
+++ b/include/engine/routing_algorithms/routing_base.hpp
@@ -181,6 +181,7 @@ void annotatePath(const FacadeT &facade,
         BOOST_ASSERT(datasource_vector.size() > 0);
         BOOST_ASSERT(weight_vector.size() + 1 == id_vector.size());
         BOOST_ASSERT(duration_vector.size() + 1 == id_vector.size());
+
         const bool is_first_segment = unpacked_path.empty();
 
         const std::size_t start_index =
@@ -405,6 +406,22 @@ InternalRouteResult extractRoute(const DataFacade<AlgorithmT> &facade,
     return raw_route_data;
 }
 
+template <typename FacadeT> EdgeDistance computeEdgeDistance(const FacadeT &facade, NodeID node_id)
+{
+    const auto geometry_index = facade.GetGeometryIndex(node_id);
+
+    EdgeDistance total_distance = 0.0;
+
+    auto geometry_range = facade.GetUncompressedForwardGeometry(geometry_index.id);
+    for (auto current = geometry_range.begin(); current < geometry_range.end() - 1; ++current)
+    {
+        total_distance += util::coordinate_calculation::fccApproximateDistance(
+            facade.GetCoordinateOfNode(*current), facade.GetCoordinateOfNode(*std::next(current)));
+    }
+
+    return total_distance;
+}
+
 } // namespace routing_algorithms
 } // namespace engine
 } // namespace osrm
diff --git a/include/engine/routing_algorithms/routing_base_ch.hpp b/include/engine/routing_algorithms/routing_base_ch.hpp
index 5ecbc6b2928..051b5f8c4a6 100644
--- a/include/engine/routing_algorithms/routing_base_ch.hpp
+++ b/include/engine/routing_algorithms/routing_base_ch.hpp
@@ -288,6 +288,106 @@ void unpackPath(const DataFacade<Algorithm> &facade,
     }
 }
 
+template <typename BidirectionalIterator>
+EdgeDistance calculateEBGNodeAnnotations(const DataFacade<Algorithm> &facade,
+                                         BidirectionalIterator packed_path_begin,
+                                         BidirectionalIterator packed_path_end)
+{
+    // Make sure we have at least something to unpack
+    if (packed_path_begin == packed_path_end ||
+        std::distance(packed_path_begin, packed_path_end) <= 1)
+        return 0;
+
+    std::stack<std::tuple<NodeID, NodeID, bool>> recursion_stack;
+    std::stack<EdgeDistance> distance_stack;
+    // We have to push the path in reverse order onto the stack because it's LIFO.
+    for (auto current = std::prev(packed_path_end); current > packed_path_begin;
+         current = std::prev(current))
+    {
+        recursion_stack.emplace(*std::prev(current), *current, false);
+    }
+
+    std::tuple<NodeID, NodeID, bool> edge;
+    while (!recursion_stack.empty())
+    {
+        edge = recursion_stack.top();
+        recursion_stack.pop();
+
+        // Have we processed the edge before? tells us if we have values in the durations stack that
+        // we can add up
+        if (!std::get<2>(edge))
+        { // haven't processed edge before, so process it in the body!
+
+            std::get<2>(edge) = true; // mark that this edge will now be processed
+
+            // Look for an edge on the forward CH graph (.forward)
+            EdgeID smaller_edge_id =
+                facade.FindSmallestEdge(std::get<0>(edge), std::get<1>(edge), [](const auto &data) {
+                    return data.forward;
+                });
+
+            // If we didn't find one there, the we might be looking at a part of the path that
+            // was found using the backward search.  Here, we flip the node order (.second,
+            // .first) and only consider edges with the `.backward` flag.
+            if (SPECIAL_EDGEID == smaller_edge_id)
+            {
+                smaller_edge_id =
+                    facade.FindSmallestEdge(std::get<1>(edge),
+                                            std::get<0>(edge),
+                                            [](const auto &data) { return data.backward; });
+            }
+
+            // If we didn't find anything *still*, then something is broken and someone has
+            // called this function with bad values.
+            BOOST_ASSERT_MSG(smaller_edge_id != SPECIAL_EDGEID, "Invalid smaller edge ID");
+
+            const auto &data = facade.GetEdgeData(smaller_edge_id);
+            BOOST_ASSERT_MSG(data.weight != std::numeric_limits<EdgeWeight>::max(),
+                             "edge weight invalid");
+
+            // If the edge is a shortcut, we need to add the two halfs to the stack.
+            if (data.shortcut)
+            { // unpack
+                const NodeID middle_node_id = data.turn_id;
+                // Note the order here - we're adding these to a stack, so we
+                // want the first->middle to get visited before middle->second
+                recursion_stack.emplace(edge);
+                recursion_stack.emplace(middle_node_id, std::get<1>(edge), false);
+                recursion_stack.emplace(std::get<0>(edge), middle_node_id, false);
+            }
+            else
+            {
+                // compute the duration here and put it onto the duration stack using method
+                // similar to annotatePath but smaller
+                EdgeDistance distance = computeEdgeDistance(facade, std::get<0>(edge));
+                distance_stack.emplace(distance);
+            }
+        }
+        else
+        { // the edge has already been processed. this means that there are enough values in the
+            // distances stack
+
+            BOOST_ASSERT_MSG(distance_stack.size() >= 2,
+                             "There are not enough (at least 2) values on the distance stack");
+            EdgeDistance distance1 = distance_stack.top();
+            distance_stack.pop();
+            EdgeDistance distance2 = distance_stack.top();
+            distance_stack.pop();
+            EdgeDistance distance = distance1 + distance2;
+            distance_stack.emplace(distance);
+        }
+    }
+
+    EdgeDistance total_distance = 0;
+    while (!distance_stack.empty())
+    {
+        total_distance += distance_stack.top();
+        distance_stack.pop();
+    }
+
+    return total_distance;
+}
+
 template <typename RandomIter, typename FacadeT>
 void unpackPath(const FacadeT &facade,
                 RandomIter packed_path_begin,
@@ -340,6 +440,11 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
                                       const NodeID middle_node_id,
                                       std::vector<NodeID> &packed_path);
 
+void retrievePackedPathFromSingleManyToManyHeap(
+    const SearchEngineData<Algorithm>::ManyToManyQueryHeap &search_heap,
+    const NodeID middle_node_id,
+    std::vector<NodeID> &packed_path);
+
 // assumes that heaps are already setup correctly.
 // ATTENTION: This only works if no additional offset is supplied next to the Phantom Node
 // Offsets.
diff --git a/include/engine/routing_algorithms/routing_base_mld.hpp b/include/engine/routing_algorithms/routing_base_mld.hpp
index cd4f0846a6a..ce9b23d70a0 100644
--- a/include/engine/routing_algorithms/routing_base_mld.hpp
+++ b/include/engine/routing_algorithms/routing_base_mld.hpp
@@ -54,7 +54,7 @@ inline bool checkParentCellRestriction(CellID, const PhantomNodes &) { return tr
 
 // Restricted search (Args is LevelID, CellID):
 //   * use the fixed level for queries
-//   * check if the node cell is the same as the specified parent onr
+//   * check if the node cell is the same as the specified parent
 template <typename MultiLevelPartition>
 inline LevelID getNodeQueryLevel(const MultiLevelPartition &, NodeID, LevelID level, CellID)
 {
@@ -65,6 +65,61 @@ inline bool checkParentCellRestriction(CellID cell, LevelID, CellID parent)
 {
     return cell == parent;
 }
+
+// Unrestricted search with a single phantom node (Args is const PhantomNode &):
+//   * use partition.GetQueryLevel to find the node query level
+//   * allow to traverse all cells
+template <typename MultiLevelPartition>
+inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
+                                 const NodeID node,
+                                 const PhantomNode &phantom_node)
+{
+    auto highest_diffrent_level = [&partition, node](const SegmentID &phantom_node) {
+        if (phantom_node.enabled)
+            return partition.GetHighestDifferentLevel(phantom_node.id, node);
+        return INVALID_LEVEL_ID;
+    };
+
+    const auto node_level = std::min(highest_diffrent_level(phantom_node.forward_segment_id),
+                                     highest_diffrent_level(phantom_node.reverse_segment_id));
+
+    return node_level;
+}
+
+// Unrestricted search with a single phantom node and a vector of phantom nodes:
+//   * use partition.GetQueryLevel to find the node query level
+//   * allow to traverse all cells
+template <typename MultiLevelPartition>
+inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
+                                 NodeID node,
+                                 const std::vector<PhantomNode> &phantom_nodes,
+                                 const std::size_t phantom_index,
+                                 const std::vector<std::size_t> &phantom_indices)
+{
+    auto min_level = [&partition, node](const PhantomNode &phantom_node) {
+
+        const auto &forward_segment = phantom_node.forward_segment_id;
+        const auto forward_level =
+            forward_segment.enabled ? partition.GetHighestDifferentLevel(node, forward_segment.id)
+                                    : INVALID_LEVEL_ID;
+
+        const auto &reverse_segment = phantom_node.reverse_segment_id;
+        const auto reverse_level =
+            reverse_segment.enabled ? partition.GetHighestDifferentLevel(node, reverse_segment.id)
+                                    : INVALID_LEVEL_ID;
+
+        return std::min(forward_level, reverse_level);
+    };
+
+    // Get minimum level over all phantoms of the highest different level with respect to node
+    // This is equivalent to min_{∀ source, target} partition.GetQueryLevel(source, node, target)
+    auto result = min_level(phantom_nodes[phantom_index]);
+    for (const auto &index : phantom_indices)
+    {
+        result = std::min(result, min_level(phantom_nodes[index]));
+    }
+    return result;
+}
 }
 
 // Heaps only record for each node its predecessor ("parent") on the shortest path.
@@ -74,6 +129,46 @@ inline bool checkParentCellRestriction(CellID cell, LevelID, CellID parent)
 using PackedEdge = std::tuple</*from*/ NodeID, /*to*/ NodeID, /*from_clique_arc*/ bool>;
 using PackedPath = std::vector<PackedEdge>;
 
+template <bool DIRECTION, typename OutIter>
+inline void retrievePackedPathFromSingleManyToManyHeap(
+    const SearchEngineData<Algorithm>::ManyToManyQueryHeap &heap, const NodeID middle, OutIter out)
+{
+
+    NodeID current = middle;
+    NodeID parent = heap.GetData(current).parent;
+
+    while (current != parent)
+    {
+        const auto &data = heap.GetData(current);
+
+        if (DIRECTION == FORWARD_DIRECTION)
+        {
+            *out = std::make_tuple(parent, current, data.from_clique_arc);
+            ++out;
+        }
+        else if (DIRECTION == REVERSE_DIRECTION)
+        {
+            *out = std::make_tuple(current, parent, data.from_clique_arc);
+            ++out;
+        }
+
+        current = parent;
+        parent = heap.GetData(parent).parent;
+    }
+}
+
+template <bool DIRECTION>
+inline PackedPath retrievePackedPathFromSingleManyToManyHeap(
+    const SearchEngineData<Algorithm>::ManyToManyQueryHeap &heap, const NodeID middle)
+{
+
+    PackedPath packed_path;
+    retrievePackedPathFromSingleManyToManyHeap<DIRECTION>(
+        heap, middle, std::back_inserter(packed_path));
+
+    return packed_path;
+}
+
 template <bool DIRECTION, typename OutIter>
 inline void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHeap &heap,
                                              const NodeID middle,
@@ -206,15 +301,22 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
     for (const auto edge : facade.GetBorderEdgeRange(level, node))
     {
         const auto &edge_data = facade.GetEdgeData(edge);
-        if (DIRECTION == FORWARD_DIRECTION ? edge_data.forward : edge_data.backward)
+
+        if ((DIRECTION == FORWARD_DIRECTION) ? facade.IsForwardEdge(edge)
+                                             : facade.IsBackwardEdge(edge))
         {
             const NodeID to = facade.GetTarget(edge);
 
             if (!facade.ExcludeNode(to) &&
                 checkParentCellRestriction(partition.GetCell(level + 1, to), args...))
             {
-                BOOST_ASSERT_MSG(edge_data.weight > 0, "edge_weight invalid");
-                const EdgeWeight to_weight = weight + edge_data.weight;
+                const auto node_weight =
+                    facade.GetNodeWeight(DIRECTION == FORWARD_DIRECTION ? node : to);
+                const auto turn_penalty = facade.GetWeightPenaltyForEdgeID(edge_data.turn_id);
+
+                // TODO: BOOST_ASSERT(edge_data.weight == node_weight + turn_penalty);
+
+                const EdgeWeight to_weight = weight + node_weight + turn_penalty;
 
                 if (!forward_heap.WasInserted(to))
                 {
@@ -407,6 +509,90 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
     return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }
 
+// With (s, middle, t) we trace back the paths middle -> s and middle -> t.
+// This gives us a packed path (node ids) from the base graph around s and t,
+// and overlay node ids otherwise. We then have to unpack the overlay clique
+// edges by recursively descending unpacking the path down to the base graph.
+
+using UnpackedNodes = std::vector<NodeID>;
+using UnpackedEdges = std::vector<EdgeID>;
+using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
+
+template <typename Algorithm, typename... Args>
+UnpackedPath
+unpackPathAndCalculateDistance(SearchEngineData<Algorithm> &engine_working_data,
+                               const DataFacade<Algorithm> &facade,
+                               typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                               typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                               const bool force_loop_forward,
+                               const bool force_loop_reverse,
+                               EdgeWeight weight_upper_bound,
+                               PackedPath packed_path,
+                               NodeID middle,
+                               Args... args)
+{
+    EdgeWeight weight = weight_upper_bound;
+    const auto &partition = facade.GetMultiLevelPartition();
+    const NodeID source_node = !packed_path.empty() ? std::get<0>(packed_path.front()) : middle;
+
+    // Unpack path
+    std::vector<NodeID> unpacked_nodes;
+    std::vector<EdgeID> unpacked_edges;
+    unpacked_nodes.reserve(packed_path.size());
+    unpacked_edges.reserve(packed_path.size());
+
+    unpacked_nodes.push_back(source_node);
+
+    for (auto const &packed_edge : packed_path)
+    {
+        NodeID source, target;
+        bool overlay_edge;
+        std::tie(source, target, overlay_edge) = packed_edge;
+        if (!overlay_edge)
+        { // a base graph edge
+            unpacked_nodes.push_back(target);
+            unpacked_edges.push_back(facade.FindEdge(source, target));
+        }
+        else
+        { // an overlay graph edge
+            LevelID level = getNodeQueryLevel(partition, source, args...);
+            CellID parent_cell_id = partition.GetCell(level, source);
+            BOOST_ASSERT(parent_cell_id == partition.GetCell(level, target));
+
+            LevelID sublevel = level - 1;
+
+            // Here heaps can be reused, let's go deeper!
+            forward_heap.Clear();
+            reverse_heap.Clear();
+            forward_heap.Insert(source, 0, {source});
+            reverse_heap.Insert(target, 0, {target});
+
+            // TODO: when structured bindings will be allowed change to
+            // auto [subpath_weight, subpath_source, subpath_target, subpath] = ...
+            EdgeWeight subpath_weight;
+            std::vector<NodeID> subpath_nodes;
+            std::vector<EdgeID> subpath_edges;
+            std::tie(subpath_weight, subpath_nodes, subpath_edges) = search(engine_working_data,
+                                                                            facade,
+                                                                            forward_heap,
+                                                                            reverse_heap,
+                                                                            force_loop_forward,
+                                                                            force_loop_reverse,
+                                                                            weight_upper_bound,
+                                                                            sublevel,
+                                                                            parent_cell_id);
+            BOOST_ASSERT(!subpath_edges.empty());
+            BOOST_ASSERT(subpath_nodes.size() > 1);
+            BOOST_ASSERT(subpath_nodes.front() == source);
+            BOOST_ASSERT(subpath_nodes.back() == target);
+            unpacked_nodes.insert(
+                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
+            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
+        }
+    }
+    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
+}
+
 // Alias to be compatible with the CH-based search
 template <typename Algorithm>
 inline void search(SearchEngineData<Algorithm> &engine_working_data,
diff --git a/include/extractor/edge_based_graph_factory.hpp b/include/extractor/edge_based_graph_factory.hpp
index 61e2f1cbfb9..d8e8aeedc88 100644
--- a/include/extractor/edge_based_graph_factory.hpp
+++ b/include/extractor/edge_based_graph_factory.hpp
@@ -91,6 +91,7 @@ class EdgeBasedGraphFactory
     void GetEdgeBasedNodeSegments(std::vector<EdgeBasedNodeSegment> &nodes);
     void GetStartPointMarkers(std::vector<bool> &node_is_startpoint);
     void GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &output_node_weights);
+    void GetEdgeBasedNodeDurations(std::vector<EdgeWeight> &output_node_durations);
     std::uint32_t GetConnectivityChecksum() const;
 
     std::uint64_t GetNumberOfEdgeBasedNodes() const;
@@ -117,6 +118,7 @@ class EdgeBasedGraphFactory
     //! node weights that indicate the length of the segment (node based) represented by the
     //! edge-based node
     std::vector<EdgeWeight> m_edge_based_node_weights;
+    std::vector<EdgeDuration> m_edge_based_node_durations;
 
     //! list of edge based nodes (compressed segments)
     std::vector<EdgeBasedNodeSegment> m_edge_based_node_segments;
diff --git a/include/extractor/extractor.hpp b/include/extractor/extractor.hpp
index 0427cfaba98..31b1576586b 100644
--- a/include/extractor/extractor.hpp
+++ b/include/extractor/extractor.hpp
@@ -87,6 +87,7 @@ class Extractor
         std::vector<EdgeBasedNodeSegment> &edge_based_node_segments,
         std::vector<bool> &node_is_startpoint,
         std::vector<EdgeWeight> &edge_based_node_weights,
+        std::vector<EdgeDuration> &edge_based_node_durations,
         util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
         std::uint32_t &connectivity_checksum);
 
diff --git a/include/extractor/files.hpp b/include/extractor/files.hpp
index cb0e87499ef..91f98825af8 100644
--- a/include/extractor/files.hpp
+++ b/include/extractor/files.hpp
@@ -462,14 +462,28 @@ void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeigtsVec
     storage::serialization::read(reader, "/extractor/edge_based_node_weights", weights);
 }
 
-template <typename NodeWeigtsVectorT>
-void writeEdgeBasedNodeWeights(const boost::filesystem::path &path,
-                               const NodeWeigtsVectorT &weights)
+template <typename NodeWeigtsVectorT, typename NodeDurationsVectorT>
+void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+                                       NodeWeigtsVectorT &weights,
+                                       NodeDurationsVectorT &durations)
+{
+    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
+    storage::tar::FileReader reader{path, fingerprint};
+
+    storage::serialization::read(reader, "/extractor/edge_based_node_weights", weights);
+    storage::serialization::read(reader, "/extractor/edge_based_node_durations", durations);
+}
+
+template <typename NodeWeigtsVectorT, typename NodeDurationsVectorT>
+void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+                                        const NodeWeigtsVectorT &weights,
+                                        const NodeDurationsVectorT &durations)
 {
     const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
     storage::tar::FileWriter writer{path, fingerprint};
 
     storage::serialization::write(writer, "/extractor/edge_based_node_weights", weights);
+    storage::serialization::write(writer, "/extractor/edge_based_node_durations", durations);
 }
 
 template <typename RTreeT>
@@ -506,29 +520,6 @@ void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT
 
     storage::serialization::read(reader, "/extractor/cnbg", edge_list);
 }
-
-// reads .osrm.maneuver_overrides
-template <typename StorageManeuverOverrideT, typename NodeSequencesT>
-inline void readManeuverOverrides(const boost::filesystem::path &path,
-                                  StorageManeuverOverrideT &maneuver_overrides,
-                                  NodeSequencesT &node_sequences)
-{
-    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
-    storage::io::FileReader reader{path, fingerprint};
-
-    serialization::read(reader, maneuver_overrides, node_sequences);
-}
-
-// writes .osrm.maneuver_overrides
-inline void writeManeuverOverrides(const boost::filesystem::path &path,
-                                   const std::vector<StorageManeuverOverride> &maneuver_overrides,
-                                   const std::vector<NodeID> &node_sequences)
-{
-    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
-    storage::io::FileWriter writer{path, fingerprint};
-
-    serialization::write(writer, maneuver_overrides, node_sequences);
-}
 }
 }
 }
diff --git a/include/nodejs/node_osrm_support.hpp b/include/nodejs/node_osrm_support.hpp
index 2bad0a205cd..6ffea408b66 100644
--- a/include/nodejs/node_osrm_support.hpp
+++ b/include/nodejs/node_osrm_support.hpp
@@ -1064,6 +1064,46 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         }
     }
 
+    if (obj->Has(Nan::New("annotations").ToLocalChecked()))
+    {
+        v8::Local<v8::Value> annotations = obj->Get(Nan::New("annotations").ToLocalChecked());
+        if (annotations.IsEmpty())
+            return table_parameters_ptr();
+
+        if (!annotations->IsArray())
+        {
+            Nan::ThrowError(
+                "Annotations must an array containing 'duration' or 'distance', or both");
+            return table_parameters_ptr();
+        }
+
+        params->annotations = osrm::TableParameters::AnnotationsType::None;
+
+        v8::Local<v8::Array> annotations_array = v8::Local<v8::Array>::Cast(annotations);
+        for (std::size_t i = 0; i < annotations_array->Length(); ++i)
+        {
+            const Nan::Utf8String annotations_utf8str(annotations_array->Get(i));
+            std::string annotations_str{*annotations_utf8str,
+                                        *annotations_utf8str + annotations_utf8str.length()};
+
+            if (annotations_str == "duration")
+            {
+                params->annotations =
+                    params->annotations | osrm::TableParameters::AnnotationsType::Duration;
+            }
+            else if (annotations_str == "distance")
+            {
+                params->annotations =
+                    params->annotations | osrm::TableParameters::AnnotationsType::Distance;
+            }
+            else
+            {
+                Nan::ThrowError("this 'annotations' param is not supported");
+                return table_parameters_ptr();
+            }
+        }
+    }
+
     return params;
 }
 
diff --git a/include/partitioner/files.hpp b/include/partitioner/files.hpp
index 3a85a8fb0f7..30bd2942d48 100644
--- a/include/partitioner/files.hpp
+++ b/include/partitioner/files.hpp
@@ -1,8 +1,6 @@
 #ifndef OSRM_PARTITIONER_SERILIZATION_HPP
 #define OSRM_PARTITIONER_SERILIZATION_HPP
 
-#include "customizer/edge_based_graph.hpp"
-
 #include "partitioner/serialization.hpp"
 
 #include "storage/io.hpp"
@@ -14,39 +12,6 @@ namespace partitioner
 namespace files
 {
 
-// reads .osrm.mldgr file
-template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path,
-                      MultiLevelGraphT &graph,
-                      std::uint32_t &connectivity_checksum)
-{
-    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
-                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
-                  "");
-
-    storage::tar::FileReader reader{path, storage::tar::FileReader::VerifyFingerprint};
-
-    reader.ReadInto("/mld/connectivity_checksum", connectivity_checksum);
-    serialization::read(reader, "/mld/multilevelgraph", graph);
-}
-
-// writes .osrm.mldgr file
-template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path,
-                       const MultiLevelGraphT &graph,
-                       const std::uint32_t connectivity_checksum)
-{
-    static_assert(std::is_same<customizer::MultiLevelEdgeBasedGraphView, MultiLevelGraphT>::value ||
-                      std::is_same<customizer::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value,
-                  "");
-
-    storage::tar::FileWriter writer{path, storage::tar::FileWriter::GenerateFingerprint};
-
-    writer.WriteElementCount64("/mld/connectivity_checksum", 1);
-    writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
-    serialization::write(writer, "/mld/multilevelgraph", graph);
-}
-
 // read .osrm.partition file
 template <typename MultiLevelPartitionT>
 inline void readPartition(const boost::filesystem::path &path, MultiLevelPartitionT &mlp)
@@ -102,6 +67,35 @@ inline void writeCells(const boost::filesystem::path &path, CellStorageT &storag
 
     serialization::write(writer, "/mld/cellstorage", storage);
 }
+
+// reads .osrm.mldgr file
+template <typename MultiLevelGraphT>
+inline void readGraph(const boost::filesystem::path &path,
+                      MultiLevelGraphT &graph,
+                      std::uint32_t &connectivity_checksum)
+{
+    static_assert(std::is_same<partitioner::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value, "");
+
+    storage::tar::FileReader reader{path, storage::tar::FileReader::VerifyFingerprint};
+
+    reader.ReadInto("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::read(reader, "/mld/multilevelgraph", graph);
+}
+
+// writes .osrm.mldgr file
+template <typename MultiLevelGraphT>
+inline void writeGraph(const boost::filesystem::path &path,
+                       const MultiLevelGraphT &graph,
+                       const std::uint32_t connectivity_checksum)
+{
+    static_assert(std::is_same<partitioner::MultiLevelEdgeBasedGraph, MultiLevelGraphT>::value, "");
+
+    storage::tar::FileWriter writer{path, storage::tar::FileWriter::GenerateFingerprint};
+
+    writer.WriteElementCount64("/mld/connectivity_checksum", 1);
+    writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
+    serialization::write(writer, "/mld/multilevelgraph", graph);
+}
 }
 }
 }
diff --git a/include/partitioner/multi_level_graph.hpp b/include/partitioner/multi_level_graph.hpp
index b652589f62a..2d563579025 100644
--- a/include/partitioner/multi_level_graph.hpp
+++ b/include/partitioner/multi_level_graph.hpp
@@ -1,6 +1,7 @@
 #ifndef OSRM_PARTITIONER_MULTI_LEVEL_GRAPH_HPP
 #define OSRM_PARTITIONER_MULTI_LEVEL_GRAPH_HPP
 
+#include "partitioner/edge_based_graph.hpp"
 #include "partitioner/multi_level_partition.hpp"
 
 #include "storage/shared_memory_ownership.hpp"
@@ -42,6 +43,8 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
     template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
 
   public:
+    using SuperT::SuperT;
+
     // We limit each node to have 255 edges
     // this is very generous, we could probably pack this
     using EdgeOffset = std::uint8_t;
@@ -146,6 +149,14 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
         return max_border_node_id;
     }
 
+    auto data() && // rvalue ref-qualifier is a safety-belt
+    {
+        return std::make_tuple(std::move(SuperT::node_array),
+                               std::move(SuperT::edge_array),
+                               std::move(node_to_edge_offset),
+                               connectivity_checksum);
+    }
+
   private:
     template <typename ContainerT>
     auto GetHighestBorderLevel(const MultiLevelPartition &mlp, const ContainerT &edges) const
@@ -218,9 +229,13 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
                                                const std::string &name,
                                                const MultiLevelGraph<EdgeDataT, Ownership> &graph);
 
+  protected:
     Vector<EdgeOffset> node_to_edge_offset;
     std::uint32_t connectivity_checksum;
 };
+
+using MultiLevelEdgeBasedGraph =
+    MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
 }
 }
 
diff --git a/include/partitioner/partitioner_config.hpp b/include/partitioner/partitioner_config.hpp
index 31423c919bd..04809dff457 100644
--- a/include/partitioner/partitioner_config.hpp
+++ b/include/partitioner/partitioner_config.hpp
@@ -16,7 +16,7 @@ namespace partitioner
 struct PartitionerConfig final : storage::IOConfig
 {
     PartitionerConfig()
-        : IOConfig({".osrm", ".osrm.fileIndex", ".osrm.ebg_nodes"},
+        : IOConfig({".osrm", ".osrm.fileIndex", ".osrm.ebg_nodes", ".osrm.enw"},
                    {".osrm.hsgr", ".osrm.cnbg"},
                    {".osrm.ebg",
                     ".osrm.cnbg",
diff --git a/include/partitioner/serialization.hpp b/include/partitioner/serialization.hpp
index b8d57bb6dbc..6f43c02eaeb 100644
--- a/include/partitioner/serialization.hpp
+++ b/include/partitioner/serialization.hpp
@@ -19,26 +19,6 @@ namespace partitioner
 namespace serialization
 {
 
-template <typename EdgeDataT, storage::Ownership Ownership>
-inline void read(storage::tar::FileReader &reader,
-                 const std::string &name,
-                 MultiLevelGraph<EdgeDataT, Ownership> &graph)
-{
-    storage::serialization::read(reader, name + "/node_array", graph.node_array);
-    storage::serialization::read(reader, name + "/edge_array", graph.edge_array);
-    storage::serialization::read(reader, name + "/node_to_edge_offset", graph.node_to_edge_offset);
-}
-
-template <typename EdgeDataT, storage::Ownership Ownership>
-inline void write(storage::tar::FileWriter &writer,
-                  const std::string &name,
-                  const MultiLevelGraph<EdgeDataT, Ownership> &graph)
-{
-    storage::serialization::write(writer, name + "/node_array", graph.node_array);
-    storage::serialization::write(writer, name + "/edge_array", graph.edge_array);
-    storage::serialization::write(writer, name + "/node_to_edge_offset", graph.node_to_edge_offset);
-}
-
 template <storage::Ownership Ownership>
 inline void read(storage::tar::FileReader &reader,
                  const std::string &name,
diff --git a/include/server/api/table_parameter_grammar.hpp b/include/server/api/table_parameter_grammar.hpp
index 5a97c8e3d40..5be79364501 100644
--- a/include/server/api/table_parameter_grammar.hpp
+++ b/include/server/api/table_parameter_grammar.hpp
@@ -22,11 +22,11 @@ namespace qi = boost::spirit::qi;
 
 template <typename Iterator = std::string::iterator,
           typename Signature = void(engine::api::TableParameters &)>
-struct TableParametersGrammar final : public BaseParametersGrammar<Iterator, Signature>
+struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature>
 {
     using BaseGrammar = BaseParametersGrammar<Iterator, Signature>;
 
-    TableParametersGrammar() : BaseGrammar(root_rule)
+    TableParametersGrammar() : TableParametersGrammar(root_rule)
     {
 #ifdef BOOST_HAS_LONG_LONG
         if (std::is_same<std::size_t, unsigned long long>::value)
@@ -51,15 +51,35 @@ struct TableParametersGrammar final : public BaseParametersGrammar<Iterator, Sig
         table_rule = destinations_rule(qi::_r1) | sources_rule(qi::_r1);
 
         root_rule = BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
-                    -('?' > (table_rule(qi::_r1) | BaseGrammar::base_rule(qi::_r1)) % '&');
+                    -('?' > (table_rule(qi::_r1) | base_rule(qi::_r1)) % '&');
     }
 
+    TableParametersGrammar(qi::rule<Iterator, Signature> &root_rule_) : BaseGrammar(root_rule_)
+    {
+        using AnnotationsType = engine::api::TableParameters::AnnotationsType;
+
+        annotations.add("duration", AnnotationsType::Duration)("distance",
+                                                               AnnotationsType::Distance);
+
+        annotations_list = annotations[qi::_val |= qi::_1] % ',';
+
+        base_rule = BaseGrammar::base_rule(qi::_r1) |
+                    (qi::lit("annotations=") >
+                     annotations_list[ph::bind(&engine::api::TableParameters::annotations,
+                                               qi::_r1) = qi::_1]);
+    }
+
+  protected:
+    qi::rule<Iterator, Signature> base_rule;
+
   private:
     qi::rule<Iterator, Signature> root_rule;
     qi::rule<Iterator, Signature> table_rule;
     qi::rule<Iterator, Signature> sources_rule;
     qi::rule<Iterator, Signature> destinations_rule;
     qi::rule<Iterator, std::size_t()> size_t_;
+    qi::symbols<char, engine::api::TableParameters::AnnotationsType> annotations;
+    qi::rule<Iterator, engine::api::TableParameters::AnnotationsType()> annotations_list;
 };
 }
 }
diff --git a/include/storage/shared_data_index.hpp b/include/storage/shared_data_index.hpp
index 0c6bd79423f..94f78182ac7 100644
--- a/include/storage/shared_data_index.hpp
+++ b/include/storage/shared_data_index.hpp
@@ -46,33 +46,39 @@ class SharedDataIndex
 
     template <typename T> auto GetBlockPtr(const std::string &name) const
     {
-        const auto index_iter = block_to_region.find(name);
-        const auto &region = regions[index_iter->second];
+        const auto &region = GetBlockRegion(name);
         return region.layout.GetBlockPtr<T>(region.memory_ptr, name);
     }
 
     template <typename T> auto GetBlockPtr(const std::string &name)
     {
-        const auto index_iter = block_to_region.find(name);
-        const auto &region = regions[index_iter->second];
+        const auto &region = GetBlockRegion(name);
         return region.layout.GetBlockPtr<T>(region.memory_ptr, name);
     }
 
     std::size_t GetBlockEntries(const std::string &name) const
     {
-        const auto index_iter = block_to_region.find(name);
-        const auto &region = regions[index_iter->second];
+        const auto &region = GetBlockRegion(name);
         return region.layout.GetBlockEntries(name);
     }
 
     std::size_t GetBlockSize(const std::string &name) const
     {
-        const auto index_iter = block_to_region.find(name);
-        const auto &region = regions[index_iter->second];
+        const auto &region = GetBlockRegion(name);
         return region.layout.GetBlockSize(name);
     }
 
   private:
+    const AllocatedRegion &GetBlockRegion(const std::string &name) const
+    {
+        const auto index_iter = block_to_region.find(name);
+        if (index_iter == block_to_region.end())
+        {
+            throw util::exception("data block " + name + " not found " + SOURCE_REF);
+        }
+        return regions[index_iter->second];
+    }
+
     std::vector<AllocatedRegion> regions;
     std::unordered_map<std::string, std::uint32_t> block_to_region;
 };
diff --git a/include/storage/view_factory.hpp b/include/storage/view_factory.hpp
index cf6839a050a..f6c8e213739 100644
--- a/include/storage/view_factory.hpp
+++ b/include/storage/view_factory.hpp
@@ -330,9 +330,18 @@ inline auto make_multi_level_graph_view(const SharedDataIndex &index, const std:
         index, name + "/edge_array");
     auto node_to_offset = make_vector_view<customizer::MultiLevelEdgeBasedGraphView::EdgeOffset>(
         index, name + "/node_to_edge_offset");
-
-    return customizer::MultiLevelEdgeBasedGraphView(
-        std::move(node_list), std::move(edge_list), std::move(node_to_offset));
+    auto node_weights = make_vector_view<EdgeWeight>(index, name + "/node_weights");
+    auto node_durations = make_vector_view<EdgeDuration>(index, name + "/node_durations");
+    auto is_forward_edge = make_vector_view<bool>(index, name + "/is_forward_edge");
+    auto is_backward_edge = make_vector_view<bool>(index, name + "/is_backward_edge");
+
+    return customizer::MultiLevelEdgeBasedGraphView(std::move(node_list),
+                                                    std::move(edge_list),
+                                                    std::move(node_to_offset),
+                                                    std::move(node_weights),
+                                                    std::move(node_durations),
+                                                    std::move(is_forward_edge),
+                                                    std::move(is_backward_edge));
 }
 
 inline auto make_maneuver_overrides_views(const SharedDataIndex &index, const std::string &name)
diff --git a/include/updater/updater.hpp b/include/updater/updater.hpp
index 08b451f0c1f..dcaf5f638a8 100644
--- a/include/updater/updater.hpp
+++ b/include/updater/updater.hpp
@@ -17,13 +17,15 @@ class Updater
   public:
     Updater(UpdaterConfig config_) : config(std::move(config_)) {}
 
-    using NumNodesAndEdges =
-        std::tuple<EdgeID, std::vector<extractor::EdgeBasedEdge>, std::uint32_t>;
-    NumNodesAndEdges LoadAndUpdateEdgeExpandedGraph() const;
+    EdgeID
+    LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
+                                   std::vector<EdgeWeight> &node_weights,
+                                   std::uint32_t &connectivity_checksum) const;
 
     EdgeID
     LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
                                    std::vector<EdgeWeight> &node_weights,
+                                   std::vector<EdgeDuration> &node_durations, // TODO: to be deleted
                                    std::uint32_t &connectivity_checksum) const;
 
   private:
diff --git a/include/updater/updater_config.hpp b/include/updater/updater_config.hpp
index cd41bac54db..64306a609b4 100644
--- a/include/updater/updater_config.hpp
+++ b/include/updater/updater_config.hpp
@@ -53,7 +53,8 @@ struct UpdaterConfig final : storage::IOConfig
                     ".osrm.geometry",
                     ".osrm.fileIndex",
                     ".osrm.properties",
-                    ".osrm.restrictions"},
+                    ".osrm.restrictions",
+                    ".osrm.enw"},
                    {},
                    {".osrm.datasource_names"}),
           valid_now(0)
diff --git a/include/util/coordinate_calculation.hpp b/include/util/coordinate_calculation.hpp
index aa60504ed8b..c946842a23e 100644
--- a/include/util/coordinate_calculation.hpp
+++ b/include/util/coordinate_calculation.hpp
@@ -43,6 +43,9 @@ inline double radToDeg(const double radian)
 //! Takes the squared euclidean distance of the input coordinates. Does not return meters!
 std::uint64_t squaredEuclideanDistance(const Coordinate lhs, const Coordinate rhs);
 
+double fccApproximateDistance(const Coordinate first_coordinate,
+                              const Coordinate second_coordinate);
+
 double haversineDistance(const Coordinate first_coordinate, const Coordinate second_coordinate);
 
 double greatCircleDistance(const Coordinate first_coordinate, const Coordinate second_coordinate);
diff --git a/include/util/debug.hpp b/include/util/debug.hpp
index c1ed8344294..9c6582dad2b 100644
--- a/include/util/debug.hpp
+++ b/include/util/debug.hpp
@@ -22,7 +22,7 @@ namespace util
 inline std::ostream &operator<<(std::ostream &out, const Coordinate &coordinate)
 {
     out << std::setprecision(12) << "{" << toFloating(coordinate.lon) << ", "
-        << toFloating(coordinate.lon) << "}";
+        << toFloating(coordinate.lat) << "}";
     return out;
 }
 }
diff --git a/include/util/dynamic_graph.hpp b/include/util/dynamic_graph.hpp
index 6fd599759e3..2a22aeae7c8 100644
--- a/include/util/dynamic_graph.hpp
+++ b/include/util/dynamic_graph.hpp
@@ -413,6 +413,11 @@ template <typename EdgeDataT> class DynamicGraph
         util::inplacePermutation(node_array.begin(), node_array.end(), old_to_new_node);
 
         // Build up edge permutation
+        if (edge_list.size() >= std::numeric_limits<EdgeID>::max())
+        {
+            throw util::exception("There are too many edges, OSRM only supports 2^32" + SOURCE_REF);
+        }
+
         EdgeID new_edge_index = 0;
         std::vector<EdgeID> old_to_new_edge(edge_list.size(), SPECIAL_EDGEID);
         for (auto node : util::irange<NodeID>(0, number_of_nodes))
@@ -421,11 +426,6 @@ template <typename EdgeDataT> class DynamicGraph
             // move all filled edges
             for (auto edge : GetAdjacentEdgeRange(node))
             {
-                if (new_edge_index == std::numeric_limits<EdgeID>::max())
-                {
-                    throw util::exception("There are too many edges, OSRM only supports 2^32" +
-                                          SOURCE_REF);
-                }
                 edge_list[edge].target = old_to_new_node[edge_list[edge].target];
                 BOOST_ASSERT(edge_list[edge].target != SPECIAL_NODEID);
                 old_to_new_edge[edge] = new_edge_index++;
diff --git a/include/util/query_heap.hpp b/include/util/query_heap.hpp
index e547ac9735d..f4b9e626ab0 100644
--- a/include/util/query_heap.hpp
+++ b/include/util/query_heap.hpp
@@ -226,12 +226,14 @@ class QueryHeap
     Data &GetData(NodeID node)
     {
         const auto index = node_index.peek_index(node);
+        BOOST_ASSERT((int)index >= 0 && (int)index < (int)inserted_nodes.size());
         return inserted_nodes[index].data;
     }
 
     Data const &GetData(NodeID node) const
     {
         const auto index = node_index.peek_index(node);
+        BOOST_ASSERT((int)index >= 0 && (int)index < (int)inserted_nodes.size());
         return inserted_nodes[index].data;
     }
 
diff --git a/include/util/static_graph.hpp b/include/util/static_graph.hpp
index 433a830c1a5..6092dd955a2 100644
--- a/include/util/static_graph.hpp
+++ b/include/util/static_graph.hpp
@@ -312,7 +312,7 @@ class StaticGraph
         });
     }
 
-    // private:
+  protected:
     NodeIterator number_of_nodes;
     EdgeIterator number_of_edges;
 
diff --git a/include/util/typedefs.hpp b/include/util/typedefs.hpp
index 9b8ecc82bbc..f0104e7b258 100644
--- a/include/util/typedefs.hpp
+++ b/include/util/typedefs.hpp
@@ -75,6 +75,7 @@ using NameID = std::uint32_t;
 using AnnotationID = std::uint32_t;
 using EdgeWeight = std::int32_t;
 using EdgeDuration = std::int32_t;
+using EdgeDistance = float;
 using SegmentWeight = std::uint32_t;
 using SegmentDuration = std::uint32_t;
 using TurnPenalty = std::int16_t; // turn penalty in 100ms units
@@ -113,6 +114,7 @@ static const SegmentDuration MAX_SEGMENT_DURATION = INVALID_SEGMENT_DURATION - 1
 static const EdgeWeight INVALID_EDGE_WEIGHT = std::numeric_limits<EdgeWeight>::max();
 static const EdgeDuration MAXIMAL_EDGE_DURATION = std::numeric_limits<EdgeDuration>::max();
 static const TurnPenalty INVALID_TURN_PENALTY = std::numeric_limits<TurnPenalty>::max();
+static const EdgeDistance INVALID_EDGE_DISTANCE = std::numeric_limits<EdgeDistance>::max();
 
 // FIXME the bitfields we use require a reduced maximal duration, this should be kept consistent
 // within the code base. For now we have to ensure that we don't case 30 bit to -1 and break any
diff --git a/include/util/vector_tile.hpp b/include/util/vector_tile.hpp
index f3c05791ef7..d3d4978b11a 100644
--- a/include/util/vector_tile.hpp
+++ b/include/util/vector_tile.hpp
@@ -9,31 +9,6 @@ namespace util
 {
 namespace vector_tile
 {
-
-const constexpr std::uint32_t ID_TAG = 1;
-const constexpr std::uint32_t NAME_TAG = 1;
-const constexpr std::uint32_t FEATURE_TAG = 2;
-const constexpr std::uint32_t LAYER_TAG = 3;
-const constexpr std::uint32_t GEOMETRY_TAG = 3;
-const constexpr std::uint32_t KEY_TAG = 3;
-const constexpr std::uint32_t VARIANT_TAG = 4;
-const constexpr std::uint32_t EXTENT_TAG = 5;
-const constexpr std::uint32_t VERSION_TAG = 15;
-
-const constexpr std::uint32_t FEATURE_ATTRIBUTES_TAG = 2;
-const constexpr std::uint32_t FEATURE_GEOMETRIES_TAG = 4;
-
-const constexpr std::uint32_t GEOMETRY_TYPE_POINT = 1;
-const constexpr std::uint32_t GEOMETRY_TYPE_LINE = 2;
-
-const constexpr std::uint32_t VARIANT_TYPE_STRING = 1;
-const constexpr std::uint32_t VARIANT_TYPE_FLOAT = 2;
-const constexpr std::uint32_t VARIANT_TYPE_DOUBLE = 3;
-
-const constexpr std::uint32_t VARIANT_TYPE_UINT64 = 5;
-const constexpr std::uint32_t VARIANT_TYPE_SINT64 = 6;
-const constexpr std::uint32_t VARIANT_TYPE_BOOL = 7;
-
 // Vector tiles are 4096 virtual pixels on each side
 const constexpr double EXTENT = 4096.0;
 const constexpr double BUFFER = 128.0;
diff --git a/package.json b/package.json
index 28acff87ec4..29ef7bca01a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.17.3",
+  "version": "5.18.0",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {
@@ -38,19 +38,25 @@
     "node": ">=4.0.0"
   },
   "devDependencies": {
+    "ansi-escape-sequences": "^4.0.0",
     "aws-sdk": "~2.0.31",
     "babel-plugin-transform-class-properties": "^6.24.1",
     "chalk": "^1.1.3",
+    "command-line-args": "^5.0.2",
+    "command-line-usage": "^5.0.4",
+    "csv-stringify": "^3.0.0",
     "cucumber": "^1.2.1",
     "d3-queue": "^2.0.3",
     "docbox": "^1.0.6",
     "documentation": "^4.0.0-rc.1",
     "eslint": "^2.4.0",
     "faucet": "^0.0.1",
+    "jsonpath": "^1.0.0",
     "node-timeout": "0.0.4",
     "polyline": "^0.2.0",
     "request": "^2.69.0",
     "tape": "^4.7.0",
+    "turf": "^3.0.14",
     "xmlbuilder": "^4.2.1"
   },
   "bundleDependencies": [
diff --git a/profiles/bicycle.lua b/profiles/bicycle.lua
index 2641526a6ce..f08bcebe26d 100644
--- a/profiles/bicycle.lua
+++ b/profiles/bicycle.lua
@@ -193,6 +193,16 @@ function setup()
       sett = 10
     },
 
+    classes = Sequence {
+        'ferry', 'tunnel'
+    },
+
+    -- Which classes should be excludable
+    -- This increases memory usage so its disabled by default.
+    excludable = Sequence {
+--        Set {'ferry'}
+    },
+
     tracktype_speeds = {
     },
 
@@ -650,6 +660,9 @@ function process_way(profile, way, result)
     -- set name, ref and pronunciation
     WayHandlers.names,
 
+    -- set classes
+    WayHandlers.classes,
+
     -- set weight properties of the way
     WayHandlers.weights
   }
diff --git a/profiles/lib/way_handlers.lua b/profiles/lib/way_handlers.lua
index 68e2706d9bc..ef9fa88e8c0 100644
--- a/profiles/lib/way_handlers.lua
+++ b/profiles/lib/way_handlers.lua
@@ -306,37 +306,46 @@ end
 
 -- add class information
 function WayHandlers.classes(profile,way,result,data)
+    if not profile.classes then
+        return
+    end
+
+    local allowed_classes = Set {}
+    for k, v in pairs(profile.classes) do
+        allowed_classes[v] = true
+    end
+
     local forward_toll, backward_toll = Tags.get_forward_backward_by_key(way, data, "toll")
     local forward_route, backward_route = Tags.get_forward_backward_by_key(way, data, "route")
     local tunnel = way:get_value_by_key("tunnel")
 
-    if tunnel and tunnel ~= "no" then
+    if allowed_classes["tunnel"] and tunnel and tunnel ~= "no" then
       result.forward_classes["tunnel"] = true
       result.backward_classes["tunnel"] = true
     end
 
-    if forward_toll == "yes" then
+    if allowed_classes["toll"] and forward_toll == "yes" then
         result.forward_classes["toll"] = true
     end
-    if backward_toll == "yes" then
+    if allowed_classes["toll"] and backward_toll == "yes" then
         result.backward_classes["toll"] = true
     end
 
-    if forward_route == "ferry" then
+    if allowed_classes["ferry"] and forward_route == "ferry" then
         result.forward_classes["ferry"] = true
     end
-    if backward_route == "ferry" then
+    if allowed_classes["ferry"] and backward_route == "ferry" then
         result.backward_classes["ferry"] = true
     end
 
-    if result.forward_restricted then
+    if allowed_classes["restricted"] and result.forward_restricted then
         result.forward_classes["restricted"] = true
     end
-    if result.backward_restricted then
+    if allowed_classes["restricted"] and result.backward_restricted then
         result.backward_classes["restricted"] = true
     end
 
-    if data.highway == "motorway" or data.highway == "motorway_link" then
+    if allowed_classes["motorway"] and (data.highway == "motorway" or data.highway == "motorway_link") then
         result.forward_classes["motorway"] = true
         result.backward_classes["motorway"] = true
     end
diff --git a/profiles/testbot.lua b/profiles/testbot.lua
index d4288bd8137..691e5761772 100644
--- a/profiles/testbot.lua
+++ b/profiles/testbot.lua
@@ -5,7 +5,7 @@
 -- Secondary road:  18km/h = 18000m/3600s = 100m/20s
 -- Tertiary road:  12km/h = 12000m/3600s = 100m/30s
 
-api_version = 3
+api_version = 4
 
 function setup()
   return {
@@ -14,7 +14,7 @@ function setup()
       max_speed_for_map_matching    = 30/3.6, --km -> m/s
       weight_name                   = 'duration',
       process_call_tagless_node     = false,
-      uturn_penalty                 = 20,
+      u_turn_penalty                 = 20,
       traffic_light_penalty         = 7,     -- seconds
       use_turn_restrictions         = true
     },
@@ -32,7 +32,7 @@ function setup()
       primary = 36,
       secondary = 18,
       tertiary = 12,
-      steps = 6,
+      steps = 6
     }
   }
 end
@@ -128,9 +128,9 @@ function process_way (profile, way, result)
 end
 
 function process_turn (profile, turn)
-  if turn.direction_modifier == direction_modifier.uturn then
-    turn.duration = profile.properties.uturn_penalty
-    turn.weight = profile.properties.uturn_penalty
+  if turn.is_u_turn then
+    turn.duration = turn.duration + profile.properties.u_turn_penalty
+    turn.weight = turn.weight + profile.properties.u_turn_penalty
   end
   if turn.has_traffic_light then
      turn.duration = turn.duration + profile.properties.traffic_light_penalty
diff --git a/scripts/gdb_printers.py b/scripts/gdb_printers.py
index ca9568c8341..f9f5062d2c9 100644
--- a/scripts/gdb_printers.py
+++ b/scripts/gdb_printers.py
@@ -9,6 +9,8 @@
 
 def call(this, method, *args):
     """Call this.method(args)"""
+    if (str(this) == '<optimized out>'):
+        raise BaseException('"this" is optimized out')
     command = '(*({})({})).{}({})'.format(this.type.target().pointer(), this.address, method, ','.join((str(x) for x in args)))
     return gdb.parse_and_eval(command)
 
@@ -234,7 +236,6 @@ def Facade(facade, width, height, arg):
             mld_facade = facade.cast(gdb.lookup_type('osrm::engine::datafacade::ContiguousInternalMemoryAlgorithmDataFacade<osrm::engine::routing_algorithms::mld::Algorithm>'))
             mld_partition = mld_facade['mld_partition']
             mld_levels = call(mld_partition, 'GetNumberOfLevels')
-            print (mld_level, mld_levels)
             if mld_level < mld_levels:
                 sentinel_node = call(mld_partition['partition'], 'size') - 1 # GetSentinelNode
                 number_of_cells = call(mld_partition, 'GetCell', mld_level, sentinel_node) # GetNumberOfCells
@@ -272,6 +273,7 @@ def Facade(facade, width, height, arg):
         for node in nodes:
             geometry_id = call(facade, 'GetGeometryIndex', node)
             direction = 'forward' if geometry_id['forward'] else 'reverse'
+            print (geometry_id, direction)
             geometry = SVGPrinter.getByGeometryId(facade, geometry_id, 'Geometry')
             weights = SVGPrinter.getByGeometryId(facade, geometry_id, 'Weights')
 
diff --git a/scripts/osrm-runner.js b/scripts/osrm-runner.js
index 7f22d0576d1..76486496910 100755
--- a/scripts/osrm-runner.js
+++ b/scripts/osrm-runner.js
@@ -10,13 +10,12 @@ const clu = require('command-line-usage');
 const ansi = require('ansi-escape-sequences');
 const turf = require('turf');
 const jp = require('jsonpath');
+const csv_stringify = require('csv-stringify/lib/sync');
 
 const run_query = (query_options, filters, callback) => {
     let tic = () => 0.;
     http.request(query_options, function (res) {
         let body = '', ttfb = tic();
-        if (res.statusCode != 200)
-            return callback(query_options.path, res.statusCode, ttfb);
 
         res.setEncoding('utf8');
         res.on('data', function (chunk) {
@@ -35,27 +34,51 @@ const run_query = (query_options, filters, callback) => {
     }).end();
 };
 
-function generate_points(polygon, number) {
+function generate_points(polygon, number, coordinates_number, max_distance) {
     let query_points = [];
     while (query_points.length < number) {
-    var chunk = turf
-        .random('points', number, { bbox: turf.bbox(polygon)})
-        .features
-        .map(x => x.geometry.coordinates)
-        .filter(pt => turf.inside(pt, polygon));
-        query_points = query_points.concat(chunk);
+        let points = [];
+
+        while(points.length < coordinates_number) {
+            let chunk = turf
+                .random('points', coordinates_number, { bbox: turf.bbox(polygon)})
+                .features
+                .map(x => x.geometry.coordinates)
+                .filter(pt => turf.inside(pt, polygon));
+
+            if (max_distance > 0)
+            {
+                chunk.forEach(pt => {
+                    if (points.length == 0)
+                    {
+                        points.push(pt);
+                    }
+                    else
+                    {
+                        let distance = turf.distance(pt, points[points.length-1], 'meters');
+                        if (distance < max_distance)
+                        {
+                            points.push(pt);
+                        }
+                    }
+                });
+            }
+            else
+            {
+                points = points.concat(chunk);
+            }
+        }
+
+        query_points.push(points);
     }
-    return query_points.slice(0, number);
+
+    return query_points;
 }
 
-function generate_queries(options, query_points, coordinates_number) {
-    let queries = [];
-    for (let chunk = 0; chunk < query_points.length; chunk += coordinates_number)
-    {
-        let points = query_points.slice(chunk, chunk + coordinates_number);
-        let query = options.path.replace(/{}/g, x =>  points.pop().join(','));
-        queries.push(query);
-    }
+function generate_queries(options, query_points) {
+    let queries = query_points.map(points => {
+        return options.path.replace(/{}/g, x =>  points.pop().join(','));
+    });
     return queries;
 }
 
@@ -73,27 +96,22 @@ function BoundingBox(x) {
 }
 const optionsList = [
     {name: 'help', alias: 'h', type: Boolean, description: 'Display this usage guide.', defaultValue: false},
-    {name: 'server', alias: 's', type: ServerDetails, defaultValue: ServerDetails('localhost:5000'),
-     description: 'OSRM routing server', typeLabel: '[underline]{hostname[:port]}'},
-    {name: 'path', alias: 'p', type: String, defaultValue: '/route/v1/driving/{};{}',
-     description: 'OSRM query path with {} coordinate placeholders, default /route/v1/driving/{};{}', typeLabel: '[underline]{path}'},
-    {name: 'filter', alias: 'f', type: String, defaultValue: ['$.routes[0].weight'], multiple: true,
-     description: 'JSONPath filters, default "$.routes[0].weight"', typeLabel: '[underline]{filter}'},
-    {name: 'bounding-box', alias: 'b', type: BoundingBox, defaultValue: BoundingBox('5.86442,47.2654,15.0508,55.1478'), multiple: true,
-     description: 'queries bounding box, default "5.86442,47.2654,15.0508,55.1478"', typeLabel: '[underline]{west,south,east,north}'},
-    {name: 'max-sockets', alias: 'm', type: Number, defaultValue: 1,
-     description: 'how many concurrent sockets the agent can have open per origin, default 1', typeLabel: '[underline]{number}'},
-    {name: 'number', alias: 'n', type: Number, defaultValue: 10,
-     description: 'number of query points, default 10', typeLabel: '[underline]{number}'},
-    {name: 'queries-files', alias: 'q', type: String,
-     description: 'CSV file with queries in the first row', typeLabel: '[underline]{file}'}];
+    {name: 'server', alias: 's', type: ServerDetails, defaultValue: ServerDetails('localhost:5000'), description: 'OSRM routing server', typeLabel: '{underline hostname[:port]}'},
+    {name: 'path', alias: 'p', type: String, defaultValue: '/route/v1/driving/{};{}', description: 'OSRM query path with \\{\\} coordinate placeholders, default /route/v2/driving/\\{\\};\\{\\}', typeLabel: '{underline path}'},
+    {name: 'filter', alias: 'f', type: String, defaultValue: ['$.routes[0].weight'], multiple: true, description: 'JSONPath filters, default "$.routes[0].weight"', typeLabel: '{underline filter}'},
+    {name: 'bounding-box', alias: 'b', type: BoundingBox, defaultValue: BoundingBox('5.86442,47.2654,15.0508,55.1478'), multiple: true, description: 'queries bounding box, default "5.86442,47.2654,15.0508,55.1478"', typeLabel: '{underline west,south,east,north}'},
+    {name: 'max-sockets', alias: 'm', type: Number, defaultValue: 1, description: 'how many concurrent sockets the agent can have open per origin, default 1', typeLabel: '{underline number}'},
+    {name: 'number', alias: 'n', type: Number, defaultValue: 10, description: 'number of query points, default 10', typeLabel: '{underline number}'},
+    {name: 'max-distance', alias: 'd', type: Number, defaultValue: -1, description: 'maximal distance between coordinates', typeLabel: '{underline number}'},
+    {name: 'queries-files', alias: 'q', type: String, description: 'CSV file with queries in the first row', typeLabel: '{underline file}'},
+];
 const options = cla(optionsList);
 if (options.help) {
-    const banner =
-          String.raw`  ____  _______  __  ___  ___  __  ___  ___  _________  ` + '\n' +
-          String.raw` / __ \/ __/ _ \/  |/  / / _ \/ / / / |/ / |/ / __/ _ \ ` + '\n' +
-          String.raw`/ /_/ /\ \/ , _/ /|_/ / / , _/ /_/ /    /    / _// , _/ ` + '\n' +
-          String.raw`\____/___/_/|_/_/  /_/ /_/|_|\____/_/|_/_/|_/___/_/|_|  `;
+    const banner =`\
+  ____  _______  __  ______  __  ___  ___  _________
+ / __ \\\\/ __/ _ \\\\/  |/  / _ \\\\/ / / / |/ / |/ / __/ _ \\\\
+/ /_/ /\\\\ \\\\/ , _/ /|_/ / , _/ /_/ /    /    / _// , _/
+\\\\____/___/_/|_/_/  /_/_/|_|\\\\____/_/|_/_/|_/___/_/|_|`;
     const usage = clu([
         { content: ansi.format(banner, 'green'), raw: true },
         { header: 'Run OSRM queries and collect results'/*, content: 'Generates something [italic]{very} important.'*/ },
@@ -114,8 +132,8 @@ if (options.hasOwnProperty('queries-files')) {
 } else {
     const polygon = options['bounding-box'].map(x => x.poly).reduce((x,y) => turf.union(x, y));
     const coordinates_number = (options.path.match(/{}/g) || []).length;
-    const query_points = generate_points(polygon, coordinates_number * options.number);
-    queries = generate_queries(options, query_points, coordinates_number);
+    const query_points = generate_points(polygon, options.number, coordinates_number, options['max-distance']);
+    queries = generate_queries(options, query_points);
 }
 queries = queries.map(q => { return {hostname: options.server.hostname, port: options.server.port, path: q}; });
 
@@ -123,11 +141,8 @@ queries = queries.map(q => { return {hostname: options.server.hostname, port: op
 http.globalAgent.maxSockets = options['max-sockets'];
 queries.map(query => {
     run_query(query, options.filter, (query, code, ttfb, total, results) => {
-        let str = `"${query}",${code}`;
-        if (ttfb !== undefined) str += `,${ttfb}`;
-        if (total !== undefined) str += `,${total}`;
-        if (typeof results === 'object' && results.length > 0)
-            str += ',' + results.map(x => isNaN(x) ? '"' + JSON.stringify(x).replace(/\n/g, ';').replace(/"/g, "'") + '"' : Number(x)).join(',');
-        console.log(str);
+        let data = results ? JSON.stringify(results[0]) : '';
+        let record = [[query, code, ttfb, total, data]];
+        process.stdout.write(csv_stringify(record));
     });
 });
diff --git a/scripts/update_dependencies.sh b/scripts/update_dependencies.sh
index 0b7f33ec69a..57dd62659d5 100755
--- a/scripts/update_dependencies.sh
+++ b/scripts/update_dependencies.sh
@@ -9,79 +9,50 @@ set -o nounset
 # structure will be lost.
 # http://git.661346.n2.nabble.com/subtree-merges-lose-prefix-after-rebase-td7332850.html
 
-OSMIUM_REPO="https://github.com/osmcode/libosmium.git"
-OSMIUM_TAG=v2.13.1
+OSMIUM_PATH="osmcode/libosmium"
+OSMIUM_TAG=v2.14.0
 
-VARIANT_REPO="https://github.com/mapbox/variant.git"
+VARIANT_PATH="mapbox/variant"
 VARIANT_TAG=v1.1.3
 
-SOL_REPO="https://github.com/ThePhD/sol2.git"
+SOL_PATH="ThePhD/sol2"
 SOL_TAG=v2.17.5
 
-RAPIDJSON_REPO="https://github.com/miloyip/rapidjson.git"
+RAPIDJSON_PATH="Tencent/rapidjson"
 RAPIDJSON_TAG=v1.1.0
 
-MICROTAR_REPO="https://github.com/rxi/microtar"
+MICROTAR_PATH="rxi/microtar"
 MICROTAR_TAG=v0.1.0
 
-VARIANT_LATEST=$(curl "https://api.github.com/repos/mapbox/variant/releases/latest" | jq ".tag_name")
-OSMIUM_LATEST=$(curl "https://api.github.com/repos/osmcode/libosmium/releases/latest" | jq ".tag_name")
-SOL_LATEST=$(curl "https://api.github.com/repos/ThePhD/sol2/releases/latest" | jq ".tag_name")
-RAPIDJSON_LATEST=$(curl "https://api.github.com/repos/miloyip/rapidjson/releases/latest" | jq ".tag_name")
-MICROTAR_LATEST=$(curl "https://api.github.com/repos/rxi/microtar/releases/latest" | jq ".tag_name")
-
-echo "Latest osmium release is $OSMIUM_LATEST, pulling in \"$OSMIUM_TAG\""
-echo "Latest variant release is $VARIANT_LATEST, pulling in \"$VARIANT_TAG\""
-echo "Latest sol2 release is $SOL_LATEST, pulling in \"$SOL_TAG\""
-echo "Latest rapidjson release is $RAPIDJSON_LATEST, pulling in \"$RAPIDJSON_TAG\""
-echo "Latest microtar release is $MICROTAR_LATEST, pulling in \"$MICROTAR_TAG\""
-
-read -p "Update osmium (y/n) " ok
-if [[ $ok =~ [yY] ]]
-then
-  if [ -d "third_party/libosmium" ]; then
-    git subtree pull -P third_party/libosmium/ $OSMIUM_REPO $OSMIUM_TAG --squash
-  else
-    git subtree add -P third_party/libosmium/ $OSMIUM_REPO $OSMIUM_TAG --squash
-  fi
-fi
-
-read -p "Update variant (y/n) " ok
-if [[ $ok =~ [yY] ]]
-then
-  if [ -d "third_party/variant" ]; then
-    git subtree pull -P third_party/variant/ $VARIANT_REPO $VARIANT_TAG --squash
-  else
-    git subtree add -P third_party/variant/ $VARIANT_REPO $VARIANT_TAG --squash
-  fi
-fi
-
-read -p "Update sol2 (y/n) " ok
-if [[ $ok =~ [yY] ]]
-then
-  if [ -d "third_party/sol2" ]; then
-    git subtree pull -P third_party/sol2/sol2/ $SOL_REPO $SOL_TAG --squash
-  else
-    git subtree add -P third_party/sol2/sol2/ $SOL_REPO $SOL_TAG --squash
-  fi
-fi
-
-read -p "Update rapidjson (y/n) " ok
-if [[ $ok =~ [yY] ]]
-then
-  if [ -d "third_party/rapidjson" ]; then
-    git subtree pull -P third_party/rapidjson/ $RAPIDJSON_REPO $RAPIDJSON_TAG --squash
-  else
-    git subtree add -P third_party/rapidjson/ $RAPIDJSON_REPO $RAPIDJSON_TAG --squash
-  fi
-fi
-
-read -p "Update microtar (y/n) " ok
-if [[ $ok =~ [yY] ]]
-then
-  if [ -d "third_party/microtar" ]; then
-    git subtree pull -P third_party/microtar/ $MICROTAR_REPO $MICROTAR_TAG --squash
-  else
-    git subtree add -P third_party/microtar/ $MICROTAR_REPO $MICROTAR_TAG --squash
-  fi
-fi
+PROTOZERO_PATH="mapbox/protozero"
+PROTOZERO_TAG=v1.6.2
+
+VTZERO_PATH="mapbox/vtzero"
+VTZERO_TAG=v1.0.1
+
+function update_subtree () {
+    name=${1^^}
+    path=$(tmpvar=${name}_PATH && echo ${!tmpvar})
+    tag=$(tmpvar=${name}_TAG && echo ${!tmpvar})
+    dir=$(basename $path)
+    repo="https://github.com/${path}.git"
+    latest=$(curl -s "https://api.github.com/repos/${path}/releases/latest" | jq ".tag_name")
+
+    echo "Latest $1 release is ${latest}, pulling in \"${tag}\""
+
+    read -p "Update ${1} (y/n) " ok
+
+    if [[ $ok =~ [yY] ]]
+    then
+        if [ -d "third_party/$dir" ]; then
+            git subtree pull -P third_party/$dir ${repo} ${tag} --squash
+        else
+            git subtree add -P third_party/$dir ${repo} ${tag} --squash
+        fi
+    fi
+}
+
+## Update dependencies
+for dep in osmium variant sol rapidjson microtar protozero vtzero ; do
+    update_subtree $dep
+done
diff --git a/src/contractor/contractor.cpp b/src/contractor/contractor.cpp
index 416f4a62b06..266367080aa 100644
--- a/src/contractor/contractor.cpp
+++ b/src/contractor/contractor.cpp
@@ -75,6 +75,12 @@ int Contractor::Run()
     EdgeID number_of_edge_based_nodes = updater.LoadAndUpdateEdgeExpandedGraph(
         edge_based_edge_list, node_weights, connectivity_checksum);
 
+    // Convert node weights for oneway streets to INVALID_EDGE_WEIGHT
+    for (auto &weight : node_weights)
+    {
+        weight = (weight & 0x80000000) ? INVALID_EDGE_WEIGHT : weight;
+    }
+
     // Contracting the edge-expanded graph
 
     TIMER_START(contraction);
diff --git a/src/customize/customizer.cpp b/src/customize/customizer.cpp
index 50007e4f4f4..2c4f57ab893 100644
--- a/src/customize/customizer.cpp
+++ b/src/customize/customizer.cpp
@@ -74,24 +74,28 @@ void printUnreachableStatistics(const Partition &partition,
 
 auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
                                     const partitioner::MultiLevelPartition &mlp,
+                                    std::vector<EdgeWeight> &node_weights,
+                                    std::vector<EdgeDuration> &node_durations,
                                     std::uint32_t &connectivity_checksum)
 {
     updater::Updater updater(config.updater_config);
 
-    EdgeID num_nodes;
     std::vector<extractor::EdgeBasedEdge> edge_based_edge_list;
-    std::tie(num_nodes, edge_based_edge_list, connectivity_checksum) =
-        updater.LoadAndUpdateEdgeExpandedGraph();
+    EdgeID num_nodes = updater.LoadAndUpdateEdgeExpandedGraph(
+        edge_based_edge_list, node_weights, node_durations, connectivity_checksum);
 
     auto directed = partitioner::splitBidirectionalEdges(edge_based_edge_list);
-    auto tidied =
-        partitioner::prepareEdgesForUsageInGraph<StaticEdgeBasedGraphEdge>(std::move(directed));
-    auto edge_based_graph = customizer::MultiLevelEdgeBasedGraph(mlp, num_nodes, std::move(tidied));
+
+    auto tidied = partitioner::prepareEdgesForUsageInGraph<
+        typename partitioner::MultiLevelEdgeBasedGraph::InputEdge>(std::move(directed));
+
+    auto edge_based_graph =
+        partitioner::MultiLevelEdgeBasedGraph(mlp, num_nodes, std::move(tidied));
 
     return edge_based_graph;
 }
 
-std::vector<CellMetric> customizeFilteredMetrics(const MultiLevelEdgeBasedGraph &graph,
+std::vector<CellMetric> customizeFilteredMetrics(const partitioner::MultiLevelEdgeBasedGraph &graph,
                                                  const partitioner::CellStorage &storage,
                                                  const CellCustomizer &customizer,
                                                  const std::vector<std::vector<bool>> &node_filters)
@@ -119,8 +123,13 @@ int Customizer::Run(const CustomizationConfig &config)
     partitioner::MultiLevelPartition mlp;
     partitioner::files::readPartition(config.GetPath(".osrm.partition"), mlp);
 
+    std::vector<EdgeWeight> node_weights;
+    std::vector<EdgeDuration> node_durations; // TODO: to be removed later
     std::uint32_t connectivity_checksum = 0;
-    auto graph = LoadAndUpdateEdgeExpandedGraph(config, mlp, connectivity_checksum);
+    auto graph = LoadAndUpdateEdgeExpandedGraph(
+        config, mlp, node_weights, node_durations, connectivity_checksum);
+    BOOST_ASSERT(graph.GetNumberOfNodes() == node_weights.size());
+    std::for_each(node_weights.begin(), node_weights.end(), [](auto &w) { w &= 0x7fffffff; });
     util::Log() << "Loaded edge based graph: " << graph.GetNumberOfEdges() << " edges, "
                 << graph.GetNumberOfNodes() << " nodes";
 
@@ -157,7 +166,10 @@ int Customizer::Run(const CustomizationConfig &config)
     util::Log() << "MLD customization writing took " << TIMER_SEC(writing_mld_data) << " seconds";
 
     TIMER_START(writing_graph);
-    partitioner::files::writeGraph(config.GetPath(".osrm.mldgr"), graph, connectivity_checksum);
+    MultiLevelEdgeBasedGraph shaved_graph{
+        std::move(graph), std::move(node_weights), std::move(node_durations)};
+    customizer::files::writeGraph(
+        config.GetPath(".osrm.mldgr"), shaved_graph, connectivity_checksum);
     TIMER_STOP(writing_graph);
     util::Log() << "Graph writing took " << TIMER_SEC(writing_graph) << " seconds";
 
diff --git a/src/engine/plugins/table.cpp b/src/engine/plugins/table.cpp
index 54804788eb4..e10b5461ace 100644
--- a/src/engine/plugins/table.cpp
+++ b/src/engine/plugins/table.cpp
@@ -81,16 +81,21 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
     }
 
     auto snapped_phantoms = SnapPhantomNodes(phantom_nodes);
-    auto result_table =
-        algorithms.ManyToManySearch(snapped_phantoms, params.sources, params.destinations);
 
-    if (result_table.empty())
+    bool request_distance = params.annotations & api::TableParameters::AnnotationsType::Distance;
+    bool request_duration = params.annotations & api::TableParameters::AnnotationsType::Duration;
+
+    auto result_tables_pair = algorithms.ManyToManySearch(
+        snapped_phantoms, params.sources, params.destinations, request_distance, request_duration);
+
+    if ((request_duration && result_tables_pair.first.empty()) ||
+        (request_distance && result_tables_pair.second.empty()))
     {
         return Error("NoTable", "No table found", result);
     }
 
     api::TableAPI table_api{facade, params};
-    table_api.MakeResponse(result_table, snapped_phantoms, result);
+    table_api.MakeResponse(result_tables_pair, snapped_phantoms, result);
 
     return Status::Ok;
 }
diff --git a/src/engine/plugins/tile.cpp b/src/engine/plugins/tile.cpp
index 46a1493dd4b..bd776756640 100644
--- a/src/engine/plugins/tile.cpp
+++ b/src/engine/plugins/tile.cpp
@@ -1,5 +1,6 @@
 #include "guidance/turn_instruction.hpp"
 
+#include "engine/plugins/plugin_base.hpp"
 #include "engine/plugins/plugin_base.hpp"
 #include "engine/plugins/tile.hpp"
 
@@ -8,21 +9,19 @@
 #include "util/vector_tile.hpp"
 #include "util/web_mercator.hpp"
 
-#include "engine/api/json_factory.hpp"
-
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/geometries.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
 #include <boost/geometry/multi/geometries/multi_linestring.hpp>
 
-#include <protozero/pbf_writer.hpp>
-#include <protozero/varint.hpp>
+#include <vtzero/builder.hpp>
+#include <vtzero/geometry.hpp>
+#include <vtzero/index.hpp>
 
 #include <algorithm>
 #include <numeric>
 #include <string>
 #include <unordered_map>
-#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -41,45 +40,7 @@ constexpr const static int MIN_ZOOM_FOR_TURNS = 15;
 namespace
 {
 
-// Creates an indexed lookup table for values - used to encoded the vector tile
-// which uses a lookup table and index pointers for encoding
-template <typename T> struct ValueIndexer
-{
-  private:
-    std::vector<T> used_values;
-    std::unordered_map<T, std::size_t> value_offsets;
-
-  public:
-    std::size_t add(const T &value)
-    {
-        const auto found = value_offsets.find(value);
-        std::size_t offset;
-
-        if (found == value_offsets.end())
-        {
-            used_values.push_back(value);
-            offset = used_values.size() - 1;
-            value_offsets[value] = offset;
-        }
-        else
-        {
-            offset = found->second;
-        }
-
-        return offset;
-    }
-
-    std::size_t indexOf(const T &value) { return value_offsets[value]; }
-
-    const std::vector<T> &values() { return used_values; }
-
-    std::size_t size() const { return used_values.size(); }
-};
-
 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
-// TODO: Port all this encoding logic to https://github.com/mapbox/vector-tile, which wasn't
-// available when this code was originally written.
-
 // Simple container class for WGS84 coordinates
 template <typename T> struct Point final
 {
@@ -132,58 +93,15 @@ const static box_t clip_box(point_t(-util::vector_tile::BUFFER, -util::vector_ti
                             point_t(util::vector_tile::EXTENT + util::vector_tile::BUFFER,
                                     util::vector_tile::EXTENT + util::vector_tile::BUFFER));
 
-// from mapnik-vector-tile
-// Encodes a linestring using protobuf zigzag encoding
-inline bool encodeLinestring(const FixedLine &line,
-                             protozero::packed_field_uint32 &geometry,
-                             std::int32_t &start_x,
-                             std::int32_t &start_y)
-{
-    const std::size_t line_size = line.size();
-    if (line_size < 2)
-    {
-        return false;
-    }
-
-    const unsigned lineto_count = static_cast<const unsigned>(line_size) - 1;
-
-    auto pt = line.begin();
-    const constexpr int MOVETO_COMMAND = 9;
-    geometry.add_element(MOVETO_COMMAND); // move_to | (1 << 3)
-    geometry.add_element(protozero::encode_zigzag32(pt->x - start_x));
-    geometry.add_element(protozero::encode_zigzag32(pt->y - start_y));
-    start_x = pt->x;
-    start_y = pt->y;
-    // This means LINETO repeated N times
-    // See: https://github.com/mapbox/vector-tile-spec/tree/master/2.1#example-command-integers
-    geometry.add_element((lineto_count << 3u) | 2u);
-    // Now that we've issued the LINETO REPEAT N command, we append
-    // N coordinate pairs immediately after the command.
-    for (++pt; pt != line.end(); ++pt)
-    {
-        const std::int32_t dx = pt->x - start_x;
-        const std::int32_t dy = pt->y - start_y;
-        geometry.add_element(protozero::encode_zigzag32(dx));
-        geometry.add_element(protozero::encode_zigzag32(dy));
-        start_x = pt->x;
-        start_y = pt->y;
-    }
-    return true;
-}
-
-// from mapnik-vctor-tile
-// Encodes a point
-inline void encodePoint(const FixedPoint &pt, protozero::packed_field_uint32 &geometry)
-{
-    const constexpr int MOVETO_COMMAND = 9;
-    geometry.add_element(MOVETO_COMMAND);
-    const std::int32_t dx = pt.x;
-    const std::int32_t dy = pt.y;
-    // Manual zigzag encoding.
-    geometry.add_element(protozero::encode_zigzag32(dx));
-    geometry.add_element(protozero::encode_zigzag32(dy));
-}
-
+/**
+ * Return the x1,y1,x2,y2 pixel coordinates of a line in a given
+ * tile.
+ *
+ * @param start the first coordinate of the line
+ * @param target the last coordinate of the line
+ * @param tile_bbox the boundaries of the tile, in mercator coordinates
+ * @return a FixedLine with coordinates relative to the tile_bbox.
+ */
 linestring_t floatLineToTileLine(const FloatLine &geo_line, const BBox &tile_bbox)
 {
     linestring_t unclipped_line;
@@ -361,6 +279,144 @@ std::vector<NodeID> getSegregatedNodes(const DataFacadeBase &facade,
     return result;
 }
 
+struct SpeedLayer : public vtzero::layer_builder
+{
+
+    vtzero::value_index_small_uint uint_index;
+    vtzero::value_index<vtzero::double_value_type, float, std::unordered_map> double_index;
+    vtzero::value_index_internal<std::unordered_map> string_index;
+    vtzero::value_index_bool bool_index;
+
+    vtzero::index_value key_speed;
+    vtzero::index_value key_is_small;
+    vtzero::index_value key_datasource;
+    vtzero::index_value key_weight;
+    vtzero::index_value key_duration;
+    vtzero::index_value key_name;
+    vtzero::index_value key_rate;
+
+    SpeedLayer(vtzero::tile_builder &tile)
+        : layer_builder(tile, "speeds"), uint_index(*this), double_index(*this),
+          string_index(*this), bool_index(*this), key_speed(add_key_without_dup_check("speed")),
+          key_is_small(add_key_without_dup_check("is_small")),
+          key_datasource(add_key_without_dup_check("datasource")),
+          key_weight(add_key_without_dup_check("weight")),
+          key_duration(add_key_without_dup_check("duration")),
+          key_name(add_key_without_dup_check("name")), key_rate(add_key_without_dup_check("rate"))
+    {
+    }
+
+}; // struct SpeedLayer
+
+class SpeedLayerFeatureBuilder : public vtzero::linestring_feature_builder
+{
+
+    SpeedLayer &m_layer;
+
+  public:
+    SpeedLayerFeatureBuilder(SpeedLayer &layer, uint64_t id)
+        : vtzero::linestring_feature_builder(layer), m_layer(layer)
+    {
+        set_id(id);
+    }
+
+    void set_speed(unsigned int value)
+    {
+        add_property(m_layer.key_speed, m_layer.uint_index(std::min(value, 127u)));
+    }
+
+    void set_is_small(bool value) { add_property(m_layer.key_is_small, m_layer.bool_index(value)); }
+
+    void set_datasource(const std::string &value)
+    {
+        add_property(m_layer.key_datasource,
+                     m_layer.string_index(vtzero::encoded_property_value{value}));
+    }
+
+    void set_weight(double value) { add_property(m_layer.key_weight, m_layer.double_index(value)); }
+
+    void set_duration(double value)
+    {
+        add_property(m_layer.key_duration, m_layer.double_index(value));
+    }
+
+    void set_name(const boost::string_ref &value)
+    {
+        add_property(
+            m_layer.key_name,
+            m_layer.string_index(vtzero::encoded_property_value{value.data(), value.size()}));
+    }
+
+    void set_rate(double value) { add_property(m_layer.key_rate, m_layer.double_index(value)); }
+
+}; // class SpeedLayerFeatureBuilder
+
+struct TurnsLayer : public vtzero::layer_builder
+{
+
+    vtzero::value_index<vtzero::sint_value_type, int, std::unordered_map> int_index;
+    vtzero::value_index<vtzero::float_value_type, float, std::unordered_map> float_index;
+    vtzero::value_index_internal<std::unordered_map> string_index;
+
+    vtzero::index_value key_bearing_in;
+    vtzero::index_value key_turn_angle;
+    vtzero::index_value key_cost;
+    vtzero::index_value key_weight;
+    vtzero::index_value key_turn_type;
+    vtzero::index_value key_turn_modifier;
+
+    TurnsLayer(vtzero::tile_builder &tile)
+        : layer_builder(tile, "turns"), int_index(*this), float_index(*this), string_index(*this),
+          key_bearing_in(add_key_without_dup_check("bearing_in")),
+          key_turn_angle(add_key_without_dup_check("turn_angle")),
+          key_cost(add_key_without_dup_check("cost")),
+          key_weight(add_key_without_dup_check("weight")),
+          key_turn_type(add_key_without_dup_check("type")),
+          key_turn_modifier(add_key_without_dup_check("modifier"))
+    {
+    }
+
+}; // struct TurnsLayer
+
+class TurnsLayerFeatureBuilder : public vtzero::point_feature_builder
+{
+
+    TurnsLayer &m_layer;
+
+  public:
+    TurnsLayerFeatureBuilder(TurnsLayer &layer, uint64_t id)
+        : vtzero::point_feature_builder(layer), m_layer(layer)
+    {
+        set_id(id);
+    }
+
+    void set_bearing_in(int value)
+    {
+        add_property(m_layer.key_bearing_in, m_layer.int_index(value));
+    }
+
+    void set_turn_angle(int value)
+    {
+        add_property(m_layer.key_turn_angle, m_layer.int_index(value));
+    }
+
+    void set_cost(float value) { add_property(m_layer.key_cost, m_layer.float_index(value)); }
+
+    void set_weight(float value) { add_property(m_layer.key_weight, m_layer.float_index(value)); }
+
+    void set_turn(osrm::guidance::TurnInstruction value)
+    {
+        const auto type = osrm::guidance::internalInstructionTypeToString(value.type);
+        const auto modifier = osrm::guidance::instructionModifierToString(value.direction_modifier);
+        add_property(
+            m_layer.key_turn_type,
+            m_layer.string_index(vtzero::encoded_property_value{type.data(), type.size()}));
+        add_property(
+            m_layer.key_turn_modifier,
+            m_layer.string_index(vtzero::encoded_property_value{modifier.data(), modifier.size()}));
+    }
+}; // class TurnsLayerFeatureBuilder
+
 void encodeVectorTile(const DataFacadeBase &facade,
                       unsigned x,
                       unsigned y,
@@ -371,117 +427,25 @@ void encodeVectorTile(const DataFacadeBase &facade,
                       const std::vector<NodeID> &segregated_nodes,
                       std::string &pbf_buffer)
 {
-
-    std::uint8_t max_datasource_id = 0;
-
-    // Vector tiles encode properties on features as indexes into a layer-specific
-    // lookup table.  These ValueIndexer's act as memoizers for values as we discover
-    // them during edge explioration, and are then used to generate the lookup
-    // tables for each tile layer.
-    ValueIndexer<int> line_int_index;
-    ValueIndexer<util::StringView> line_string_index;
-    ValueIndexer<int> point_int_index;
-    ValueIndexer<float> point_float_index;
-    ValueIndexer<std::string> point_string_index;
+    vtzero::tile_builder tile;
 
     const auto get_geometry_id = [&facade](auto edge) {
         return facade.GetGeometryIndex(edge.forward_segment_id.id).id;
     };
 
-    // Vector tiles encode feature properties as indexes into a lookup table.  So, we need
-    // to "pre-loop" over all the edges to create the lookup tables.  Once we have those, we
-    // can then encode the features, and we'll know the indexes that feature properties
-    // need to refer to.
-    for (const auto &edge_index : sorted_edge_indexes)
-    {
-        const auto &edge = edges[edge_index];
-
-        const auto geometry_id = get_geometry_id(edge);
-        const auto forward_datasource_range = facade.GetUncompressedForwardDatasources(geometry_id);
-        const auto reverse_datasource_range = facade.GetUncompressedReverseDatasources(geometry_id);
-
-        BOOST_ASSERT(edge.fwd_segment_position < forward_datasource_range.size());
-        const auto forward_datasource = forward_datasource_range(edge.fwd_segment_position);
-        BOOST_ASSERT(edge.fwd_segment_position < reverse_datasource_range.size());
-        const auto reverse_datasource = reverse_datasource_range(reverse_datasource_range.size() -
-                                                                 edge.fwd_segment_position - 1);
-
-        // Keep track of the highest datasource seen so that we don't write unnecessary
-        // data to the layer attribute values
-        max_datasource_id = std::max(max_datasource_id, forward_datasource);
-        max_datasource_id = std::max(max_datasource_id, reverse_datasource);
-    }
-
     // Convert tile coordinates into mercator coordinates
     double min_mercator_lon, min_mercator_lat, max_mercator_lon, max_mercator_lat;
     util::web_mercator::xyzToMercator(
         x, y, z, min_mercator_lon, min_mercator_lat, max_mercator_lon, max_mercator_lat);
     const BBox tile_bbox{min_mercator_lon, min_mercator_lat, max_mercator_lon, max_mercator_lat};
 
-    // Protobuf serializes blocks when objects go out of scope, hence
-    // the extra scoping below.
-    protozero::pbf_writer tile_writer{pbf_buffer};
+    // XXX leaving in some superfluous scopes to make diff easier to read.
     {
         {
-            // Add a layer object to the PBF stream.  3=='layer' from the vector tile spec
-            // (2.1)
-            protozero::pbf_writer line_layer_writer(tile_writer, util::vector_tile::LAYER_TAG);
-            // TODO: don't write a layer if there are no features
-
-            line_layer_writer.add_uint32(util::vector_tile::VERSION_TAG, 2); // version
-            // Field 1 is the "layer name" field, it's a string
-            line_layer_writer.add_string(util::vector_tile::NAME_TAG, "speeds"); // name
-            // Field 5 is the tile extent.  It's a uint32 and should be set to 4096
-            // for normal vector tiles.
-            line_layer_writer.add_uint32(util::vector_tile::EXTENT_TAG,
-                                         util::vector_tile::EXTENT); // extent
-
-            // Because we need to know the indexes into the vector tile lookup table,
-            // we need to do an initial pass over the data and create the complete
-            // index of used values.
-            for (const auto &edge_index : sorted_edge_indexes)
-            {
-                const auto &edge = edges[edge_index];
-                const auto geometry_id = get_geometry_id(edge);
-
-                // Get coordinates for start/end nodes of segment (NodeIDs u and v)
-                const auto a = facade.GetCoordinateOfNode(edge.u);
-                const auto b = facade.GetCoordinateOfNode(edge.v);
-                // Calculate the length in meters
-                const double length = osrm::util::coordinate_calculation::haversineDistance(a, b);
-
-                // Weight values
-                const auto forward_weight_range = facade.GetUncompressedForwardWeights(geometry_id);
-                const auto reverse_weight_range = facade.GetUncompressedReverseWeights(geometry_id);
-                const auto forward_weight = forward_weight_range[edge.fwd_segment_position];
-                const auto reverse_weight = reverse_weight_range[reverse_weight_range.size() -
-                                                                 edge.fwd_segment_position - 1];
-                line_int_index.add(forward_weight);
-                line_int_index.add(reverse_weight);
-
-                std::uint32_t forward_rate =
-                    static_cast<std::uint32_t>(round(length / forward_weight * 10.));
-                std::uint32_t reverse_rate =
-                    static_cast<std::uint32_t>(round(length / reverse_weight * 10.));
-
-                line_int_index.add(forward_rate);
-                line_int_index.add(reverse_rate);
-
-                // Duration values
-                const auto forward_duration_range =
-                    facade.GetUncompressedForwardDurations(geometry_id);
-                const auto reverse_duration_range =
-                    facade.GetUncompressedReverseDurations(geometry_id);
-                const auto forward_duration = forward_duration_range[edge.fwd_segment_position];
-                const auto reverse_duration = reverse_duration_range[reverse_duration_range.size() -
-                                                                     edge.fwd_segment_position - 1];
-
-                line_int_index.add(forward_duration);
-                line_int_index.add(reverse_duration);
-            }
-
             // Begin the layer features block
             {
+                SpeedLayer speeds_layer{tile};
+
                 // Each feature gets a unique id, starting at 1
                 unsigned id = 1;
                 for (const auto &edge_index : sorted_edge_indexes)
@@ -516,7 +480,6 @@ void encodeVectorTile(const DataFacadeBase &facade,
                     const auto reverse_duration =
                         reverse_duration_range[reverse_duration_range.size() -
                                                edge.fwd_segment_position - 1];
-
                     const auto forward_datasource_idx =
                         forward_datasource_range(edge.fwd_segment_position);
                     const auto reverse_datasource_idx = reverse_datasource_range(
@@ -526,84 +489,10 @@ void encodeVectorTile(const DataFacadeBase &facade,
                     const auto name_id = facade.GetNameIndex(edge.forward_segment_id.id);
                     auto name = facade.GetNameForID(name_id);
 
-                    line_string_index.add(name);
-
-                    const auto encode_tile_line = [&line_layer_writer,
-                                                   &component_id,
-                                                   &id,
-                                                   &max_datasource_id,
-                                                   &line_int_index](
-                        const FixedLine &tile_line,
-                        const std::uint32_t speed_kmh_idx,
-                        const std::uint32_t rate_idx,
-                        const std::size_t weight_idx,
-                        const std::size_t duration_idx,
-                        const DatasourceID datasource_idx,
-                        const std::size_t name_idx,
-                        std::int32_t &start_x,
-                        std::int32_t &start_y) {
-                        // Here, we save the two attributes for our feature: the speed and
-                        // the is_small boolean.  We only serve up speeds from 0-139, so all we
-                        // do is save the first
-                        protozero::pbf_writer feature_writer(line_layer_writer,
-                                                             util::vector_tile::FEATURE_TAG);
-                        // Field 3 is the "geometry type" field.  Value 2 is "line"
-                        feature_writer.add_enum(
-                            util::vector_tile::GEOMETRY_TAG,
-                            util::vector_tile::GEOMETRY_TYPE_LINE); // geometry type
-                        // Field 1 for the feature is the "id" field.
-                        feature_writer.add_uint64(util::vector_tile::ID_TAG, id++); // id
-                        {
-                            // When adding attributes to a feature, we have to write
-                            // pairs of numbers.  The first value is the index in the
-                            // keys array (written later), and the second value is the
-                            // index into the "values" array (also written later).  We're
-                            // not writing the actual speed or bool value here, we're saving
-                            // an index into the "values" array.  This means many features
-                            // can share the same value data, leading to smaller tiles.
-                            protozero::packed_field_uint32 field(
-                                feature_writer, util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-
-                            field.add_element(0); // "speed" tag key offset
-                            field.add_element(std::min(
-                                speed_kmh_idx, 127u)); // save the speed value, capped at 127
-                            field.add_element(1);      // "is_small" tag key offset
-                            field.add_element(
-                                128 + (component_id.is_tiny ? 0 : 1)); // is_small feature offset
-                            field.add_element(2);                    // "datasource" tag key offset
-                            field.add_element(130 + datasource_idx); // datasource value offset
-                            field.add_element(3);                    // "weight" tag key offset
-                            field.add_element(130 + max_datasource_id + 1 +
-                                              weight_idx); // weight value offset
-                            field.add_element(4);          // "duration" tag key offset
-                            field.add_element(130 + max_datasource_id + 1 +
-                                              duration_idx); // duration value offset
-                            field.add_element(5);            // "name" tag key offset
-
-                            field.add_element(130 + max_datasource_id + 1 +
-                                              line_int_index.values().size() + name_idx);
-
-                            field.add_element(6); // rate tag key offset
-                            field.add_element(130 + max_datasource_id + 1 + rate_idx);
-                        }
-                        {
-
-                            // Encode the geometry for the feature
-                            protozero::packed_field_uint32 geometry(
-                                feature_writer, util::vector_tile::FEATURE_GEOMETRIES_TAG);
-                            encodeLinestring(tile_line, geometry, start_x, start_y);
-                        }
-                    };
-
                     // If this is a valid forward edge, go ahead and add it to the tile
                     if (forward_duration != 0 && edge.forward_segment_id.enabled)
                     {
-                        std::int32_t start_x = 0;
-                        std::int32_t start_y = 0;
-
                         // Calculate the speed for this line
-                        // Speeds are looked up in a simple 1:1 table, so the speed value == lookup
-                        // table index
                         std::uint32_t speed_kmh_idx =
                             static_cast<std::uint32_t>(round(length / forward_duration * 10 * 3.6));
 
@@ -616,15 +505,19 @@ void encodeVectorTile(const DataFacadeBase &facade,
                         auto tile_line = coordinatesToTileLine(a, b, tile_bbox);
                         if (!tile_line.empty())
                         {
-                            encode_tile_line(tile_line,
-                                             speed_kmh_idx,
-                                             line_int_index.indexOf(forward_rate),
-                                             line_int_index.indexOf(forward_weight),
-                                             line_int_index.indexOf(forward_duration),
-                                             forward_datasource_idx,
-                                             line_string_index.indexOf(name),
-                                             start_x,
-                                             start_y);
+                            SpeedLayerFeatureBuilder fbuilder{speeds_layer, id};
+                            fbuilder.add_linestring_from_container(tile_line);
+
+                            fbuilder.set_speed(speed_kmh_idx);
+                            fbuilder.set_is_small(component_id.is_tiny);
+                            fbuilder.set_datasource(
+                                facade.GetDatasourceName(forward_datasource_idx).to_string());
+                            fbuilder.set_weight(forward_weight / 10.0);
+                            fbuilder.set_duration(forward_duration / 10.0);
+                            fbuilder.set_name(name);
+                            fbuilder.set_rate(forward_rate / 10.0);
+
+                            fbuilder.commit();
                         }
                     }
 
@@ -632,12 +525,7 @@ void encodeVectorTile(const DataFacadeBase &facade,
                     // properties
                     if (reverse_duration != 0 && edge.reverse_segment_id.enabled)
                     {
-                        std::int32_t start_x = 0;
-                        std::int32_t start_y = 0;
-
                         // Calculate the speed for this line
-                        // Speeds are looked up in a simple 1:1 table, so the speed value == lookup
-                        // table index
                         std::uint32_t speed_kmh_idx =
                             static_cast<std::uint32_t>(round(length / reverse_duration * 10 * 3.6));
 
@@ -650,232 +538,52 @@ void encodeVectorTile(const DataFacadeBase &facade,
                         auto tile_line = coordinatesToTileLine(b, a, tile_bbox);
                         if (!tile_line.empty())
                         {
-                            encode_tile_line(tile_line,
-                                             speed_kmh_idx,
-                                             line_int_index.indexOf(reverse_rate),
-                                             line_int_index.indexOf(reverse_weight),
-                                             line_int_index.indexOf(reverse_duration),
-                                             reverse_datasource_idx,
-                                             line_string_index.indexOf(name),
-                                             start_x,
-                                             start_y);
+                            SpeedLayerFeatureBuilder fbuilder{speeds_layer, id};
+                            fbuilder.add_linestring_from_container(tile_line);
+
+                            fbuilder.set_speed(speed_kmh_idx);
+                            fbuilder.set_is_small(component_id.is_tiny);
+                            fbuilder.set_datasource(
+                                facade.GetDatasourceName(reverse_datasource_idx).to_string());
+                            fbuilder.set_weight(reverse_weight / 10.0);
+                            fbuilder.set_duration(reverse_duration / 10.0);
+                            fbuilder.set_name(name);
+                            fbuilder.set_rate(reverse_rate / 10.0);
+
+                            fbuilder.commit();
                         }
                     }
                 }
             }
-
-            // Field id 3 is the "keys" attribute
-            // We need two "key" fields, these are referred to with 0 and 1 (their array
-            // indexes) earlier
-            line_layer_writer.add_string(util::vector_tile::KEY_TAG, "speed");
-            line_layer_writer.add_string(util::vector_tile::KEY_TAG, "is_small");
-            line_layer_writer.add_string(util::vector_tile::KEY_TAG, "datasource");
-            line_layer_writer.add_string(util::vector_tile::KEY_TAG, "weight");
-            line_layer_writer.add_string(util::vector_tile::KEY_TAG, "duration");
-            line_layer_writer.add_string(util::vector_tile::KEY_TAG, "name");
-            line_layer_writer.add_string(util::vector_tile::KEY_TAG, "rate");
-
-            // Now, we write out the possible speed value arrays and possible is_tiny
-            // values.  Field type 4 is the "values" field.  It's a variable type field,
-            // so requires a two-step write (create the field, then write its value)
-            for (std::size_t i = 0; i < 128; i++)
-            {
-                // Writing field type 4 == variant type
-                protozero::pbf_writer values_writer(line_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                // Attribute value 5 == uint64 type
-                values_writer.add_uint64(util::vector_tile::VARIANT_TYPE_UINT64, i);
-            }
-            {
-                protozero::pbf_writer values_writer(line_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                // Attribute value 7 == bool type
-                values_writer.add_bool(util::vector_tile::VARIANT_TYPE_BOOL, true);
-            }
-            {
-                protozero::pbf_writer values_writer(line_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                // Attribute value 7 == bool type
-                values_writer.add_bool(util::vector_tile::VARIANT_TYPE_BOOL, false);
-            }
-            for (std::size_t i = 0; i <= max_datasource_id; i++)
-            {
-                // Writing field type 4 == variant type
-                protozero::pbf_writer values_writer(line_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                // Attribute value 1 == string type
-                values_writer.add_string(util::vector_tile::VARIANT_TYPE_STRING,
-                                         facade.GetDatasourceName(i).to_string());
-            }
-            for (auto value : line_int_index.values())
-            {
-                // Writing field type 4 == variant type
-                protozero::pbf_writer values_writer(line_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                // Attribute value 2 == float type
-                // Durations come out of OSRM in integer deciseconds, so we convert them
-                // to seconds with a simple /10 for display
-                values_writer.add_double(util::vector_tile::VARIANT_TYPE_DOUBLE, value / 10.);
-            }
-
-            for (const auto &name : line_string_index.values())
-            {
-                // Writing field type 4 == variant type
-                protozero::pbf_writer values_writer(line_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                // Attribute value 1 == string type
-                values_writer.add_string(
-                    util::vector_tile::VARIANT_TYPE_STRING, name.data(), name.size());
-            }
         }
 
         // Only add the turn layer to the tile if it has some features (we sometimes won't
         // for tiles of z<16, and tiles that don't show any intersections)
         if (!all_turn_data.empty())
         {
-
-            struct EncodedTurnData
-            {
-                util::Coordinate coordinate;
-                std::size_t angle_index;
-                std::size_t turn_index;
-                std::size_t duration_index;
-                std::size_t weight_index;
-                std::size_t turntype_index;
-                std::size_t turnmodifier_index;
-            };
-            // we need to pre-encode all values here because we need the full offsets later
-            // for encoding the actual features.
-            std::vector<EncodedTurnData> encoded_turn_data(all_turn_data.size());
-            std::transform(
-                all_turn_data.begin(),
-                all_turn_data.end(),
-                encoded_turn_data.begin(),
-                [&](const routing_algorithms::TurnData &t) {
-                    auto angle_idx = point_int_index.add(t.in_angle);
-                    auto turn_idx = point_int_index.add(t.turn_angle);
-                    auto duration_idx =
-                        point_float_index.add(t.duration / 10.0); // Note conversion to float here
-                    auto weight_idx =
-                        point_float_index.add(t.weight / 10.0); // Note conversion to float here
-
-                    auto turntype_idx = point_string_index.add(
-                        osrm::guidance::internalInstructionTypeToString(t.turn_instruction.type));
-                    auto turnmodifier_idx =
-                        point_string_index.add(osrm::guidance::instructionModifierToString(
-                            t.turn_instruction.direction_modifier));
-                    return EncodedTurnData{t.coordinate,
-                                           angle_idx,
-                                           turn_idx,
-                                           duration_idx,
-                                           weight_idx,
-                                           turntype_idx,
-                                           turnmodifier_idx};
-                });
-
-            // Now write the points layer for turn penalty data:
-            // Add a layer object to the PBF stream.  3=='layer' from the vector tile spec
-            // (2.1)
-            protozero::pbf_writer point_layer_writer(tile_writer, util::vector_tile::LAYER_TAG);
-            point_layer_writer.add_uint32(util::vector_tile::VERSION_TAG, 2);    // version
-            point_layer_writer.add_string(util::vector_tile::NAME_TAG, "turns"); // name
-            point_layer_writer.add_uint32(util::vector_tile::EXTENT_TAG,
-                                          util::vector_tile::EXTENT); // extent
-
-            // Begin writing the set of point features
+            TurnsLayer turns_layer{tile};
+            uint64_t id = 0;
+            for (const auto &turn_data : all_turn_data)
             {
-                // Start each features with an ID starting at 1
-                int id = 1;
-
-                // Helper function to encode a new point feature on a vector tile.
-                const auto encode_tile_point = [&](const FixedPoint &tile_point,
-                                                   const auto &point_turn_data) {
-                    protozero::pbf_writer feature_writer(point_layer_writer,
-                                                         util::vector_tile::FEATURE_TAG);
-                    // Field 3 is the "geometry type" field.  Value 1 is "point"
-                    feature_writer.add_enum(
-                        util::vector_tile::GEOMETRY_TAG,
-                        util::vector_tile::GEOMETRY_TYPE_POINT);                // geometry type
-                    feature_writer.add_uint64(util::vector_tile::ID_TAG, id++); // id
-                    {
-                        // Write out the 4 properties we want on the feature.  These
-                        // refer to indexes in the properties lookup table, which we
-                        // add to the tile after we add all features.
-                        protozero::packed_field_uint32 field(
-                            feature_writer, util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-                        field.add_element(0); // "bearing_in" tag key offset
-                        field.add_element(point_turn_data.angle_index);
-                        field.add_element(1); // "turn_angle" tag key offset
-                        field.add_element(point_turn_data.turn_index);
-                        field.add_element(2); // "cost" tag key offset
-                        field.add_element(point_int_index.size() + point_turn_data.duration_index);
-                        field.add_element(3); // "weight" tag key offset
-                        field.add_element(point_int_index.size() + point_turn_data.weight_index);
-                        field.add_element(4); // "type" tag key offset
-                        field.add_element(point_int_index.size() + point_float_index.size() +
-                                          point_turn_data.turntype_index);
-                        field.add_element(5); // "modifier" tag key offset
-                        field.add_element(point_int_index.size() + point_float_index.size() +
-                                          point_turn_data.turnmodifier_index);
-                    }
-                    {
-                        // Add the geometry as the last field in this feature
-                        protozero::packed_field_uint32 geometry(
-                            feature_writer, util::vector_tile::FEATURE_GEOMETRIES_TAG);
-                        encodePoint(tile_point, geometry);
-                    }
-                };
-
-                // Loop over all the turns we found and add them as features to the layer
-                for (const auto &turndata : encoded_turn_data)
+                const auto tile_point = coordinatesToTilePoint(turn_data.coordinate, tile_bbox);
+                if (boost::geometry::within(point_t(tile_point.x, tile_point.y), clip_box))
                 {
-                    const auto tile_point = coordinatesToTilePoint(turndata.coordinate, tile_bbox);
-                    if (!boost::geometry::within(point_t(tile_point.x, tile_point.y), clip_box))
-                    {
-                        continue;
-                    }
-                    encode_tile_point(tile_point, turndata);
-                }
-            }
+                    TurnsLayerFeatureBuilder fbuilder{turns_layer, ++id};
+                    fbuilder.add_point(tile_point);
 
-            // Add the names of the three attributes we added to all the turn penalty
-            // features previously.  The indexes used there refer to these keys.
-            point_layer_writer.add_string(util::vector_tile::KEY_TAG, "bearing_in");
-            point_layer_writer.add_string(util::vector_tile::KEY_TAG, "turn_angle");
-            point_layer_writer.add_string(util::vector_tile::KEY_TAG, "cost");
-            point_layer_writer.add_string(util::vector_tile::KEY_TAG, "weight");
-            point_layer_writer.add_string(util::vector_tile::KEY_TAG, "type");
-            point_layer_writer.add_string(util::vector_tile::KEY_TAG, "modifier");
-
-            // Now, save the lists of integers and floats that our features refer to.
-            for (const auto &value : point_int_index.values())
-            {
-                protozero::pbf_writer values_writer(point_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                values_writer.add_sint64(util::vector_tile::VARIANT_TYPE_SINT64, value);
-            }
-            for (const auto &value : point_float_index.values())
-            {
-                protozero::pbf_writer values_writer(point_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                values_writer.add_float(util::vector_tile::VARIANT_TYPE_FLOAT, value);
-            }
-            for (const auto &value : point_string_index.values())
-            {
-                protozero::pbf_writer values_writer(point_layer_writer,
-                                                    util::vector_tile::VARIANT_TAG);
-                values_writer.add_string(util::vector_tile::VARIANT_TYPE_STRING, value);
+                    fbuilder.set_bearing_in(turn_data.in_angle);
+                    fbuilder.set_turn_angle(turn_data.turn_angle);
+                    fbuilder.set_cost(turn_data.duration / 10.0);
+                    fbuilder.set_weight(turn_data.weight / 10.0);
+                    fbuilder.set_turn(turn_data.turn_instruction);
+
+                    fbuilder.commit();
+                }
             }
         }
 
         // OSM Node tile layer
         {
-            protozero::pbf_writer point_layer_writer(tile_writer, util::vector_tile::LAYER_TAG);
-            point_layer_writer.add_uint32(util::vector_tile::VERSION_TAG, 2);       // version
-            point_layer_writer.add_string(util::vector_tile::NAME_TAG, "osmnodes"); // name
-            point_layer_writer.add_uint32(util::vector_tile::EXTENT_TAG,
-                                          util::vector_tile::EXTENT); // extent
-
             std::vector<NodeID> internal_nodes;
             internal_nodes.reserve(edges.size() * 2);
             for (const auto &edge : edges)
@@ -887,6 +595,8 @@ void encodeVectorTile(const DataFacadeBase &facade,
             auto new_end = std::unique(internal_nodes.begin(), internal_nodes.end());
             internal_nodes.resize(new_end - internal_nodes.begin());
 
+            vtzero::layer_builder osmnodes_layer{tile, "osmnodes"};
+
             for (const auto &internal_node : internal_nodes)
             {
                 const auto coord = facade.GetCoordinateOfNode(internal_node);
@@ -895,32 +605,19 @@ void encodeVectorTile(const DataFacadeBase &facade,
                 {
                     continue;
                 }
-                protozero::pbf_writer feature_writer(point_layer_writer,
-                                                     util::vector_tile::FEATURE_TAG);
-                // Field 3 is the "geometry type" field.  Value 1 is "point"
-                feature_writer.add_enum(util::vector_tile::GEOMETRY_TAG,
-                                        util::vector_tile::GEOMETRY_TYPE_POINT); // geometry type
-                const auto osmid =
-                    static_cast<OSMNodeID::value_type>(facade.GetOSMNodeIDOfNode(internal_node));
-                feature_writer.add_uint64(util::vector_tile::ID_TAG, osmid); // id
-                // There are no additional properties, just the ID and the geometry
-                {
-                    // Add the geometry as the last field in this feature
-                    protozero::packed_field_uint32 geometry(
-                        feature_writer, util::vector_tile::FEATURE_GEOMETRIES_TAG);
-                    encodePoint(tile_point, geometry);
-                }
+
+                vtzero::point_feature_builder fbuilder{osmnodes_layer};
+                fbuilder.set_id(
+                    static_cast<OSMNodeID::value_type>(facade.GetOSMNodeIDOfNode(internal_node)));
+                fbuilder.add_point(tile_point);
+                fbuilder.commit();
             }
         }
 
+        // Internal nodes tile layer
         {
-            protozero::pbf_writer line_layer_writer(tile_writer, util::vector_tile::LAYER_TAG);
-            line_layer_writer.add_uint32(util::vector_tile::VERSION_TAG, 2);             // version
-            line_layer_writer.add_string(util::vector_tile::NAME_TAG, "internal-nodes"); // name
-            line_layer_writer.add_uint32(util::vector_tile::EXTENT_TAG,
-                                         util::vector_tile::EXTENT); // extent
+            vtzero::layer_builder internal_nodes_layer{tile, "internal-nodes"};
 
-            unsigned id = 0;
             for (auto edgeNodeID : segregated_nodes)
             {
                 auto const geomIndex = facade.GetGeometryIndex(edgeNodeID);
@@ -937,46 +634,21 @@ void encodeVectorTile(const DataFacadeBase &facade,
                         points.push_back(facade.GetCoordinateOfNode(nodeID));
                 }
 
-                const auto encode_tile_line = [&line_layer_writer, &id](
-                    const FixedLine &tile_line, std::int32_t &start_x, std::int32_t &start_y) {
-
-                    protozero::pbf_writer feature_writer(line_layer_writer,
-                                                         util::vector_tile::FEATURE_TAG);
-
-                    feature_writer.add_enum(util::vector_tile::GEOMETRY_TAG,
-                                            util::vector_tile::GEOMETRY_TYPE_LINE); // geometry type
-
-                    feature_writer.add_uint64(util::vector_tile::ID_TAG, id++); // id
-                    {
-
-                        protozero::packed_field_uint32 field(
-                            feature_writer, util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-                    }
-                    {
-
-                        // Encode the geometry for the feature
-                        protozero::packed_field_uint32 geometry(
-                            feature_writer, util::vector_tile::FEATURE_GEOMETRIES_TAG);
-                        encodeLinestring(tile_line, geometry, start_x, start_y);
-                    }
-                };
-
-                std::int32_t start_x = 0;
-                std::int32_t start_y = 0;
-
                 auto tile_lines = coordinatesToTileLine(points, tile_bbox);
                 if (!tile_lines.empty())
                 {
-                    for (auto const &tl : tile_lines)
+                    vtzero::linestring_feature_builder fbuilder{internal_nodes_layer};
+                    for (auto const &tile_line : tile_lines)
                     {
-                        encode_tile_line(tl, start_x, start_y);
+                        fbuilder.add_linestring_from_container(tile_line);
                     }
+                    fbuilder.commit();
                 }
             }
         }
     }
-    // protozero serializes data during object destructors, so once the scope closes,
-    // our result buffer will have all the tile data encoded into it.
+
+    tile.serialize(pbf_buffer);
 }
 }
 
diff --git a/src/engine/plugins/trip.cpp b/src/engine/plugins/trip.cpp
index 2347677ff43..8914c3e4834 100644
--- a/src/engine/plugins/trip.cpp
+++ b/src/engine/plugins/trip.cpp
@@ -131,7 +131,7 @@ void ManipulateTableForFSE(const std::size_t source_id,
         result_table.SetValue(destination_id, i, INVALID_EDGE_WEIGHT);
     }
 
-    // set destination->source to zero so rountrip treats source and
+    // set destination->source to zero so roundtrip treats source and
     // destination as one location
     result_table.SetValue(destination_id, source_id, 0);
 
@@ -216,61 +216,66 @@ Status TripPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
     BOOST_ASSERT(snapped_phantoms.size() == number_of_locations);
 
     // compute the duration table of all phantom nodes
-    auto result_table = util::DistTableWrapper<EdgeWeight>(
-        algorithms.ManyToManySearch(snapped_phantoms, {}, {}), number_of_locations);
-
-    if (result_table.size() == 0)
+    auto result_duration_table = util::DistTableWrapper<EdgeWeight>(
+        algorithms
+            .ManyToManySearch(
+                snapped_phantoms, {}, {}, /*requestDistance*/ false, /*requestDuration*/ true)
+            .first,
+        number_of_locations);
+
+    if (result_duration_table.size() == 0)
     {
         return Status::Error;
     }
 
     const constexpr std::size_t BF_MAX_FEASABLE = 10;
-    BOOST_ASSERT_MSG(result_table.size() == number_of_locations * number_of_locations,
+    BOOST_ASSERT_MSG(result_duration_table.size() == number_of_locations * number_of_locations,
                      "Distance Table has wrong size");
 
-    if (!IsStronglyConnectedComponent(result_table))
+    if (!IsStronglyConnectedComponent(result_duration_table))
     {
         return Error("NoTrips", "No trip visiting all destinations possible.", json_result);
     }
 
     if (fixed_start && fixed_end)
     {
-        ManipulateTableForFSE(source_id, destination_id, result_table);
+        ManipulateTableForFSE(source_id, destination_id, result_duration_table);
     }
 
-    std::vector<NodeID> trip;
-    trip.reserve(number_of_locations);
+    std::vector<NodeID> duration_trip;
+    duration_trip.reserve(number_of_locations);
     // get an optimized order in which the destinations should be visited
     if (number_of_locations < BF_MAX_FEASABLE)
     {
-        trip = trip::BruteForceTrip(number_of_locations, result_table);
+        duration_trip = trip::BruteForceTrip(number_of_locations, result_duration_table);
     }
     else
     {
-        trip = trip::FarthestInsertionTrip(number_of_locations, result_table);
+        duration_trip = trip::FarthestInsertionTrip(number_of_locations, result_duration_table);
     }
 
     // rotate result such that roundtrip starts at node with index 0
     // thist first if covers scenarios: !fixed_end || fixed_start || (fixed_start && fixed_end)
     if (!fixed_end || fixed_start)
     {
-        auto desired_start_index = std::find(std::begin(trip), std::end(trip), 0);
-        BOOST_ASSERT(desired_start_index != std::end(trip));
-        std::rotate(std::begin(trip), desired_start_index, std::end(trip));
+        auto desired_start_index = std::find(std::begin(duration_trip), std::end(duration_trip), 0);
+        BOOST_ASSERT(desired_start_index != std::end(duration_trip));
+        std::rotate(std::begin(duration_trip), desired_start_index, std::end(duration_trip));
     }
     else if (fixed_end && !fixed_start && parameters.roundtrip)
     {
-        auto desired_start_index = std::find(std::begin(trip), std::end(trip), destination_id);
-        BOOST_ASSERT(desired_start_index != std::end(trip));
-        std::rotate(std::begin(trip), desired_start_index, std::end(trip));
+        auto desired_start_index =
+            std::find(std::begin(duration_trip), std::end(duration_trip), destination_id);
+        BOOST_ASSERT(desired_start_index != std::end(duration_trip));
+        std::rotate(std::begin(duration_trip), desired_start_index, std::end(duration_trip));
     }
 
     // get the route when visiting all destinations in optimized order
     InternalRouteResult route =
-        ComputeRoute(algorithms, snapped_phantoms, trip, parameters.roundtrip);
+        ComputeRoute(algorithms, snapped_phantoms, duration_trip, parameters.roundtrip);
 
     // get api response
-    const std::vector<std::vector<NodeID>> trips = {trip};
+    const std::vector<std::vector<NodeID>> trips = {duration_trip};
     const std::vector<InternalRouteResult> routes = {route};
     api::TripAPI trip_api{facade, parameters};
     trip_api.MakeResponse(trips, routes, snapped_phantoms, json_result);
diff --git a/src/engine/routing_algorithms/alternative_path_mld.cpp b/src/engine/routing_algorithms/alternative_path_mld.cpp
index 76de45971ec..7fbe37dabfc 100644
--- a/src/engine/routing_algorithms/alternative_path_mld.cpp
+++ b/src/engine/routing_algorithms/alternative_path_mld.cpp
@@ -470,10 +470,10 @@ RandIt filterUnpackedPathsBySharing(RandIt first,
     if (shortest_path.edges.empty())
         return last;
 
-    std::unordered_set<EdgeID> edges;
-    edges.reserve(size * shortest_path.edges.size() * (1.25));
+    std::unordered_set<NodeID> nodes;
+    nodes.reserve(size * shortest_path.nodes.size() * (1.25));
 
-    edges.insert(begin(shortest_path.edges), end(shortest_path.edges));
+    nodes.insert(begin(shortest_path.nodes), end(shortest_path.nodes));
 
     const auto over_sharing_limit = [&](auto &unpacked) {
         if (unpacked.edges.empty())
@@ -482,20 +482,20 @@ RandIt filterUnpackedPathsBySharing(RandIt first,
         }
 
         EdgeWeight total_duration = 0;
-        const auto add_if_seen = [&](const EdgeWeight duration, const EdgeID edge) {
-            auto edge_duration = facade.GetEdgeData(edge).duration;
-            total_duration += edge_duration;
-            if (edges.count(edge) > 0)
+        const auto add_if_seen = [&](const EdgeWeight duration, const NodeID node) {
+            auto node_duration = facade.GetNodeDuration(node);
+            total_duration += node_duration;
+            if (nodes.count(node) > 0)
             {
-                return duration + edge_duration;
+                return duration + node_duration;
             }
             return duration;
         };
 
-        const auto shared_weight =
-            std::accumulate(begin(unpacked.edges), end(unpacked.edges), EdgeWeight{0}, add_if_seen);
+        const auto shared_duration = std::accumulate(
+            begin(unpacked.nodes), end(unpacked.nodes), EdgeDuration{0}, add_if_seen);
 
-        unpacked.sharing = shared_weight / static_cast<double>(total_duration);
+        unpacked.sharing = shared_duration / static_cast<double>(total_duration);
         BOOST_ASSERT(unpacked.sharing >= 0.);
         BOOST_ASSERT(unpacked.sharing <= 1.);
 
@@ -505,7 +505,7 @@ RandIt filterUnpackedPathsBySharing(RandIt first,
         }
         else
         {
-            edges.insert(begin(unpacked.edges), end(unpacked.edges));
+            nodes.insert(begin(unpacked.nodes), end(unpacked.nodes));
             return false;
         }
     };
diff --git a/src/engine/routing_algorithms/direct_shortest_path.cpp b/src/engine/routing_algorithms/direct_shortest_path.cpp
index 182bb7a9e9f..08ca3249e24 100644
--- a/src/engine/routing_algorithms/direct_shortest_path.cpp
+++ b/src/engine/routing_algorithms/direct_shortest_path.cpp
@@ -1,5 +1,4 @@
 #include "engine/routing_algorithms/direct_shortest_path.hpp"
-
 #include "engine/routing_algorithms/routing_base.hpp"
 #include "engine/routing_algorithms/routing_base_ch.hpp"
 #include "engine/routing_algorithms/routing_base_mld.hpp"
diff --git a/src/engine/routing_algorithms/many_to_many_ch.cpp b/src/engine/routing_algorithms/many_to_many_ch.cpp
index 807406281f8..8ee02b5ec92 100644
--- a/src/engine/routing_algorithms/many_to_many_ch.cpp
+++ b/src/engine/routing_algorithms/many_to_many_ch.cpp
@@ -60,8 +60,8 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
         if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
         {
             const NodeID to = facade.GetTarget(edge);
-
             const auto edge_weight = data.weight;
+
             const auto edge_duration = data.duration;
 
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
@@ -85,12 +85,13 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
 }
 
 void forwardRoutingStep(const DataFacade<Algorithm> &facade,
-                        const unsigned row_idx,
-                        const unsigned number_of_targets,
+                        const std::size_t row_index,
+                        const std::size_t number_of_targets,
                         typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
                         const std::vector<NodeBucket> &search_space_with_buckets,
                         std::vector<EdgeWeight> &weights_table,
                         std::vector<EdgeDuration> &durations_table,
+                        std::vector<NodeID> &middle_nodes_table,
                         const PhantomNode &phantom_node)
 {
     const auto node = query_heap.DeleteMin();
@@ -105,12 +106,12 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
     for (const auto &current_bucket : boost::make_iterator_range(bucket_list))
     {
         // Get target id from bucket entry
-        const auto column_idx = current_bucket.column_index;
+        const auto column_index = current_bucket.column_index;
         const auto target_weight = current_bucket.weight;
         const auto target_duration = current_bucket.duration;
 
-        auto &current_weight = weights_table[row_idx * number_of_targets + column_idx];
-        auto &current_duration = durations_table[row_idx * number_of_targets + column_idx];
+        auto &current_weight = weights_table[row_index * number_of_targets + column_index];
+        auto &current_duration = durations_table[row_index * number_of_targets + column_index];
 
         // Check if new weight is better
         auto new_weight = source_weight + target_weight;
@@ -122,12 +123,14 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
             {
                 current_weight = std::min(current_weight, new_weight);
                 current_duration = std::min(current_duration, new_duration);
+                middle_nodes_table[row_index * number_of_targets + column_index] = node;
             }
         }
         else if (std::tie(new_weight, new_duration) < std::tie(current_weight, current_duration))
         {
             current_weight = new_weight;
             current_duration = new_duration;
+            middle_nodes_table[row_index * number_of_targets + column_index] = node;
         }
     }
 
@@ -136,7 +139,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
 }
 
 void backwardRoutingStep(const DataFacade<Algorithm> &facade,
-                         const unsigned column_idx,
+                         const unsigned column_index,
                          typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
                          std::vector<NodeBucket> &search_space_with_buckets,
                          const PhantomNode &phantom_node)
@@ -144,9 +147,11 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto target_weight = query_heap.GetKey(node);
     const auto target_duration = query_heap.GetData(node).duration;
+    const auto parent = query_heap.GetData(node).parent;
 
     // Store settled nodes in search space bucket
-    search_space_with_buckets.emplace_back(node, column_idx, target_weight, target_duration);
+    search_space_with_buckets.emplace_back(
+        node, parent, column_index, target_weight, target_duration);
 
     relaxOutgoingEdges<REVERSE_DIRECTION>(
         facade, node, target_weight, target_duration, query_heap, phantom_node);
@@ -154,26 +159,187 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
 
 } // namespace ch
 
+void retrievePackedPathFromSearchSpace(const NodeID middle_node_id,
+                                       const unsigned column_index,
+                                       const std::vector<NodeBucket> &search_space_with_buckets,
+                                       std::vector<NodeID> &packed_leg)
+{
+    auto bucket_list = std::equal_range(search_space_with_buckets.begin(),
+                                        search_space_with_buckets.end(),
+                                        middle_node_id,
+                                        NodeBucket::ColumnCompare(column_index));
+
+    NodeID current_node_id = middle_node_id;
+
+    BOOST_ASSERT_MSG(std::distance(bucket_list.first, bucket_list.second) == 1,
+                     "The pointers are not pointing to the same element.");
+
+    while (bucket_list.first->parent_node != current_node_id &&
+           bucket_list.first != search_space_with_buckets.end())
+    {
+        current_node_id = bucket_list.first->parent_node;
+
+        packed_leg.emplace_back(current_node_id);
+
+        bucket_list = std::equal_range(search_space_with_buckets.begin(),
+                                       search_space_with_buckets.end(),
+                                       current_node_id,
+                                       NodeBucket::ColumnCompare(column_index));
+    }
+}
+
+void calculateDistances(typename SearchEngineData<ch::Algorithm>::ManyToManyQueryHeap &query_heap,
+                        const DataFacade<ch::Algorithm> &facade,
+                        const std::vector<PhantomNode> &phantom_nodes,
+                        const std::vector<std::size_t> &target_indices,
+                        const std::size_t row_index,
+                        const std::size_t source_index,
+                        const PhantomNode &source_phantom,
+                        const std::size_t number_of_targets,
+                        const std::vector<NodeBucket> &search_space_with_buckets,
+                        std::vector<EdgeDistance> &distances_table,
+                        const std::vector<NodeID> &middle_nodes_table)
+{
+    std::vector<NodeID> packed_leg;
+
+    for (auto column_index : util::irange<std::size_t>(0, number_of_targets))
+    {
+        const auto target_index = target_indices[column_index];
+        const auto &target_phantom = phantom_nodes[target_index];
+
+        if (source_index == target_index)
+        {
+            distances_table[row_index * number_of_targets + column_index] = 0.0;
+            continue;
+        }
+
+        NodeID middle_node_id = middle_nodes_table[row_index * number_of_targets + column_index];
+
+        if (middle_node_id == SPECIAL_NODEID) // takes care of one-ways
+        {
+            distances_table[row_index * number_of_targets + column_index] = INVALID_EDGE_DISTANCE;
+            continue;
+        }
+
+        // Step 1: Find path from source to middle node
+        ch::retrievePackedPathFromSingleManyToManyHeap(query_heap, middle_node_id, packed_leg);
+        std::reverse(packed_leg.begin(), packed_leg.end());
+
+        packed_leg.push_back(middle_node_id);
+
+        // Step 2: Find path from middle to target node
+        retrievePackedPathFromSearchSpace(
+            middle_node_id, column_index, search_space_with_buckets, packed_leg);
+
+        if (packed_leg.size() == 1 && (needsLoopForward(source_phantom, target_phantom) ||
+                                       needsLoopBackwards(source_phantom, target_phantom)))
+        {
+            auto weight = ch::getLoopWeight<false>(facade, packed_leg.front());
+            if (weight != INVALID_EDGE_WEIGHT)
+                packed_leg.push_back(packed_leg.front());
+        }
+        if (!packed_leg.empty())
+        {
+            auto annotation =
+                ch::calculateEBGNodeAnnotations(facade, packed_leg.begin(), packed_leg.end());
+
+            distances_table[row_index * number_of_targets + column_index] = annotation;
+
+            // check the direction of travel to figure out how to calculate the offset to/from
+            // the source/target
+            if (source_phantom.forward_segment_id.id == packed_leg.front())
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
+                //       -->s               <-- subtract offset to start at source
+                //          .........       <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                EdgeDistance offset = source_phantom.GetForwardDistance();
+                distances_table[row_index * number_of_targets + column_index] -= offset;
+            }
+            else if (source_phantom.reverse_segment_id.id == packed_leg.front())
+            {
+                //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
+                //          s<-------    <-- subtract offset to start at source
+                //       ...             <-- want this distance
+                // entry 0---1---2---3   <-- 3 is exit node
+                EdgeDistance offset = source_phantom.GetReverseDistance();
+                distances_table[row_index * number_of_targets + column_index] -= offset;
+            }
+            if (target_phantom.forward_segment_id.id == packed_leg.back())
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
+                //                   ++>t   <-- add offset to get to target
+                //       ................   <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                EdgeDistance offset = target_phantom.GetForwardDistance();
+                distances_table[row_index * number_of_targets + column_index] += offset;
+            }
+            else if (target_phantom.reverse_segment_id.id == packed_leg.back())
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0 to 3
+                //                   <++t   <-- add offset to get from target
+                //       ................   <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                EdgeDistance offset = target_phantom.GetReverseDistance();
+                distances_table[row_index * number_of_targets + column_index] += offset;
+            }
+        }
+        else
+        {
+            // there is no shortcut to unpack. source and target are on the same EBG Node.
+            // if the offset of the target is greater than the offset of the source, subtract it
+            if (target_phantom.GetForwardDistance() > source_phantom.GetForwardDistance())
+            {
+                //       --------->t        <-- offsets
+                //       ->s                <-- subtract source offset from target offset
+                //         .........        <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                EdgeDistance offset =
+                    target_phantom.GetForwardDistance() - source_phantom.GetForwardDistance();
+                distances_table[row_index * number_of_targets + column_index] = offset;
+            }
+            else
+            {
+                //               s<---      <-- offsets
+                //         t<---------      <-- subtract source offset from target offset
+                //         ......           <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                EdgeDistance offset =
+                    target_phantom.GetReverseDistance() - source_phantom.GetReverseDistance();
+                distances_table[row_index * number_of_targets + column_index] = offset;
+            }
+        }
+        packed_leg.clear();
+    }
+}
+
 template <>
-std::vector<EdgeDuration> manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
-                                           const DataFacade<ch::Algorithm> &facade,
-                                           const std::vector<PhantomNode> &phantom_nodes,
-                                           const std::vector<std::size_t> &source_indices,
-                                           const std::vector<std::size_t> &target_indices)
+std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
+manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
+                 const DataFacade<ch::Algorithm> &facade,
+                 const std::vector<PhantomNode> &phantom_nodes,
+                 const std::vector<std::size_t> &source_indices,
+                 const std::vector<std::size_t> &target_indices,
+                 const bool calculate_distance,
+                 const bool calculate_duration)
 {
+    (void)calculate_duration; // TODO: stub to use when computing durations become optional
+
     const auto number_of_sources = source_indices.size();
     const auto number_of_targets = target_indices.size();
     const auto number_of_entries = number_of_sources * number_of_targets;
 
     std::vector<EdgeWeight> weights_table(number_of_entries, INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations_table(number_of_entries, MAXIMAL_EDGE_DURATION);
+    std::vector<EdgeDistance> distances_table;
+    std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
 
     // Populate buckets with paths from all accessible nodes to destinations via backward searches
-    for (std::uint32_t column_idx = 0; column_idx < target_indices.size(); ++column_idx)
+    for (std::uint32_t column_index = 0; column_index < target_indices.size(); ++column_index)
     {
-        const auto index = target_indices[column_idx];
+        const auto index = target_indices[column_index];
         const auto &phantom = phantom_nodes[index];
 
         engine_working_data.InitializeOrClearManyToManyThreadLocalStorage(
@@ -184,7 +350,8 @@ std::vector<EdgeDuration> manyToManySearch(SearchEngineData<ch::Algorithm> &engi
         // Explore search space
         while (!query_heap.Empty())
         {
-            backwardRoutingStep(facade, column_idx, query_heap, search_space_with_buckets, phantom);
+            backwardRoutingStep(
+                facade, column_index, query_heap, search_space_with_buckets, phantom);
         }
     }
 
@@ -192,32 +359,49 @@ std::vector<EdgeDuration> manyToManySearch(SearchEngineData<ch::Algorithm> &engi
     std::sort(search_space_with_buckets.begin(), search_space_with_buckets.end());
 
     // Find shortest paths from sources to all accessible nodes
-    for (std::uint32_t row_idx = 0; row_idx < source_indices.size(); ++row_idx)
+    for (std::uint32_t row_index = 0; row_index < source_indices.size(); ++row_index)
     {
-        const auto index = source_indices[row_idx];
-        const auto &phantom = phantom_nodes[index];
+        const auto source_index = source_indices[row_index];
+        const auto &source_phantom = phantom_nodes[source_index];
 
         // Clear heap and insert source nodes
         engine_working_data.InitializeOrClearManyToManyThreadLocalStorage(
             facade.GetNumberOfNodes());
         auto &query_heap = *(engine_working_data.many_to_many_heap);
-        insertSourceInHeap(query_heap, phantom);
+        insertSourceInHeap(query_heap, source_phantom);
 
         // Explore search space
         while (!query_heap.Empty())
         {
             forwardRoutingStep(facade,
-                               row_idx,
+                               row_index,
                                number_of_targets,
                                query_heap,
                                search_space_with_buckets,
                                weights_table,
                                durations_table,
-                               phantom);
+                               middle_nodes_table,
+                               source_phantom);
+        }
+
+        if (calculate_distance)
+        {
+            distances_table.resize(number_of_entries, INVALID_EDGE_DISTANCE);
+            calculateDistances(query_heap,
+                               facade,
+                               phantom_nodes,
+                               target_indices,
+                               row_index,
+                               source_index,
+                               source_phantom,
+                               number_of_targets,
+                               search_space_with_buckets,
+                               distances_table,
+                               middle_nodes_table);
         }
     }
 
-    return durations_table;
+    return std::make_pair(durations_table, distances_table);
 }
 
 } // namespace routing_algorithms
diff --git a/src/engine/routing_algorithms/many_to_many_mld.cpp b/src/engine/routing_algorithms/many_to_many_mld.cpp
index df9010bfbef..91033abd7e3 100644
--- a/src/engine/routing_algorithms/many_to_many_mld.cpp
+++ b/src/engine/routing_algorithms/many_to_many_mld.cpp
@@ -1,5 +1,5 @@
 #include "engine/routing_algorithms/many_to_many.hpp"
-#include "engine/routing_algorithms/routing_base.hpp"
+#include "engine/routing_algorithms/routing_base_mld.hpp"
 
 #include <boost/assert.hpp>
 #include <boost/range/iterator_range_core.hpp>
@@ -19,22 +19,8 @@ namespace routing_algorithms
 namespace mld
 {
 
-template <typename MultiLevelPartition>
-inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
-                                 const NodeID node,
-                                 const PhantomNode &phantom_node)
-{
-    auto highest_diffrent_level = [&partition, node](const SegmentID &phantom_node) {
-        if (phantom_node.enabled)
-            return partition.GetHighestDifferentLevel(phantom_node.id, node);
-        return INVALID_LEVEL_ID;
-    };
-
-    const auto node_level = std::min(highest_diffrent_level(phantom_node.forward_segment_id),
-                                     highest_diffrent_level(phantom_node.reverse_segment_id));
-
-    return node_level;
-}
+using PackedEdge = std::tuple</*from*/ NodeID, /*to*/ NodeID, /*from_clique_arc*/ bool>;
+using PackedPath = std::vector<PackedEdge>;
 
 template <typename MultiLevelPartition>
 inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
@@ -50,38 +36,6 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
     return node_level;
 }
 
-template <typename MultiLevelPartition>
-inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
-                                 NodeID node,
-                                 const std::vector<PhantomNode> &phantom_nodes,
-                                 const std::size_t phantom_index,
-                                 const std::vector<std::size_t> &phantom_indices)
-{
-    auto min_level = [&partition, node](const PhantomNode &phantom_node) {
-
-        const auto &forward_segment = phantom_node.forward_segment_id;
-        const auto forward_level =
-            forward_segment.enabled ? partition.GetHighestDifferentLevel(node, forward_segment.id)
-                                    : INVALID_LEVEL_ID;
-
-        const auto &reverse_segment = phantom_node.reverse_segment_id;
-        const auto reverse_level =
-            reverse_segment.enabled ? partition.GetHighestDifferentLevel(node, reverse_segment.id)
-                                    : INVALID_LEVEL_ID;
-
-        return std::min(forward_level, reverse_level);
-    };
-
-    // Get minimum level over all phantoms of the highest different level with respect to node
-    // This is equivalent to min_{∀ source, target} partition.GetQueryLevel(source, node, target)
-    auto result = min_level(phantom_nodes[phantom_index]);
-    for (const auto &index : phantom_indices)
-    {
-        result = std::min(result, min_level(phantom_nodes[index]));
-    }
-    return result;
-}
-
 template <bool DIRECTION, typename... Args>
 void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                         const NodeID node,
@@ -125,8 +79,10 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                     {
                         query_heap.Insert(to, to_weight, {node, true, to_duration});
                     }
-                    else if (std::tie(to_weight, to_duration) <
-                             std::tie(query_heap.GetKey(to), query_heap.GetData(to).duration))
+                    else if (std::tie(to_weight, to_duration, node) <
+                             std::tie(query_heap.GetKey(to),
+                                      query_heap.GetData(to).duration,
+                                      query_heap.GetData(to).parent))
                     {
                         query_heap.GetData(to) = {node, true, to_duration};
                         query_heap.DecreaseKey(to, to_weight);
@@ -155,8 +111,10 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                     {
                         query_heap.Insert(to, to_weight, {node, true, to_duration});
                     }
-                    else if (std::tie(to_weight, to_duration) <
-                             std::tie(query_heap.GetKey(to), query_heap.GetData(to).duration))
+                    else if (std::tie(to_weight, to_duration, node) <
+                             std::tie(query_heap.GetKey(to),
+                                      query_heap.GetData(to).duration,
+                                      query_heap.GetData(to).parent))
                     {
                         query_heap.GetData(to) = {node, true, to_duration};
                         query_heap.DecreaseKey(to, to_weight);
@@ -172,7 +130,8 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
     for (const auto edge : facade.GetBorderEdgeRange(level, node))
     {
         const auto &data = facade.GetEdgeData(edge);
-        if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
+        if ((DIRECTION == FORWARD_DIRECTION) ? facade.IsForwardEdge(edge)
+                                             : facade.IsBackwardEdge(edge))
         {
             const NodeID to = facade.GetTarget(edge);
             if (facade.ExcludeNode(to))
@@ -180,12 +139,16 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                 continue;
             }
 
-            const auto edge_weight = data.weight;
-            const auto edge_duration = data.duration;
+            const auto turn_id = data.turn_id;
+            const auto node_id = DIRECTION == FORWARD_DIRECTION ? node : facade.GetTarget(edge);
+            const auto node_weight = facade.GetNodeWeight(node_id);
+            const auto node_duration = facade.GetNodeDuration(node_id);
+            const auto turn_weight = node_weight + facade.GetWeightPenaltyForEdgeID(turn_id);
+            const auto turn_duration = node_duration + facade.GetDurationPenaltyForEdgeID(turn_id);
 
-            BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
-            const auto to_weight = weight + edge_weight;
-            const auto to_duration = duration + edge_duration;
+            BOOST_ASSERT_MSG(node_weight + turn_weight > 0, "edge weight is invalid");
+            const auto to_weight = weight + turn_weight;
+            const auto to_duration = duration + turn_duration;
 
             // New Node discovered -> Add to Heap + Node Info Storage
             if (!query_heap.WasInserted(to))
@@ -193,8 +156,10 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                 query_heap.Insert(to, to_weight, {node, false, to_duration});
             }
             // Found a shorter Path -> Update weight and set new parent
-            else if (std::tie(to_weight, to_duration) <
-                     std::tie(query_heap.GetKey(to), query_heap.GetData(to).duration))
+            else if (std::tie(to_weight, to_duration, node) <
+                     std::tie(query_heap.GetKey(to),
+                              query_heap.GetData(to).duration,
+                              query_heap.GetData(to).parent))
             {
                 query_heap.GetData(to) = {node, false, to_duration};
                 query_heap.DecreaseKey(to, to_weight);
@@ -207,14 +172,18 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
 // Unidirectional multi-layer Dijkstra search for 1-to-N and N-to-1 matrices
 //
 template <bool DIRECTION>
-std::vector<EdgeDuration> oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                                          const DataFacade<Algorithm> &facade,
-                                          const std::vector<PhantomNode> &phantom_nodes,
-                                          std::size_t phantom_index,
-                                          const std::vector<std::size_t> &phantom_indices)
+std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
+oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
+                const DataFacade<Algorithm> &facade,
+                const std::vector<PhantomNode> &phantom_nodes,
+                std::size_t phantom_index,
+                const std::vector<std::size_t> &phantom_indices,
+                const bool calculate_distance)
 {
     std::vector<EdgeWeight> weights(phantom_indices.size(), INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations(phantom_indices.size(), MAXIMAL_EDGE_DURATION);
+    std::vector<EdgeDistance> distances_table;
+    std::vector<NodeID> middle_nodes_table(phantom_indices.size(), SPECIAL_NODEID);
 
     // Collect destination (source) nodes into a map
     std::unordered_multimap<NodeID, std::tuple<std::size_t, EdgeWeight, EdgeDuration>>
@@ -282,6 +251,7 @@ std::vector<EdgeDuration> oneToManySearch(SearchEngineData<Algorithm> &engine_wo
                 {
                     weights[index] = path_weight;
                     durations[index] = path_duration;
+                    middle_nodes_table[index] = node;
                 }
 
                 // Remove node from destinations list
@@ -294,21 +264,36 @@ std::vector<EdgeDuration> oneToManySearch(SearchEngineData<Algorithm> &engine_wo
         }
     };
 
-    // Check a single path result and insert adjacent nodes into heap
     auto insert_node = [&](NodeID node, EdgeWeight initial_weight, EdgeDuration initial_duration) {
 
         // Update single node paths
         update_values(node, initial_weight, initial_duration);
 
+        query_heap.Insert(node, initial_weight, {node, initial_duration});
+
         // Place adjacent nodes into heap
         for (auto edge : facade.GetAdjacentEdgeRange(node))
         {
             const auto &data = facade.GetEdgeData(edge);
-            if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
+            const auto to = facade.GetTarget(edge);
+
+            if (facade.ExcludeNode(to))
+            {
+                continue;
+            }
+
+            if ((DIRECTION == FORWARD_DIRECTION ? facade.IsForwardEdge(edge)
+                                                : facade.IsBackwardEdge(edge)) &&
+                !query_heap.WasInserted(to))
             {
-                query_heap.Insert(facade.GetTarget(edge),
-                                  data.weight + initial_weight,
-                                  {node, data.duration + initial_duration});
+                const auto turn_id = data.turn_id;
+                const auto node_id = DIRECTION == FORWARD_DIRECTION ? node : to;
+                const auto edge_weight = initial_weight + facade.GetNodeWeight(node_id) +
+                                         facade.GetWeightPenaltyForEdgeID(turn_id);
+                const auto edge_duration = initial_duration + facade.GetNodeDuration(node_id) +
+                                           facade.GetDurationPenaltyForEdgeID(turn_id);
+
+                query_heap.Insert(to, edge_weight, {node, edge_duration});
             }
         }
     };
@@ -318,28 +303,35 @@ std::vector<EdgeDuration> oneToManySearch(SearchEngineData<Algorithm> &engine_wo
 
         if (DIRECTION == FORWARD_DIRECTION)
         {
-
             if (phantom_node.IsValidForwardSource())
+            {
                 insert_node(phantom_node.forward_segment_id.id,
                             -phantom_node.GetForwardWeightPlusOffset(),
                             -phantom_node.GetForwardDuration());
+            }
 
             if (phantom_node.IsValidReverseSource())
+            {
                 insert_node(phantom_node.reverse_segment_id.id,
                             -phantom_node.GetReverseWeightPlusOffset(),
                             -phantom_node.GetReverseDuration());
+            }
         }
         else if (DIRECTION == REVERSE_DIRECTION)
         {
             if (phantom_node.IsValidForwardTarget())
+            {
                 insert_node(phantom_node.forward_segment_id.id,
                             phantom_node.GetForwardWeightPlusOffset(),
                             phantom_node.GetForwardDuration());
+            }
 
             if (phantom_node.IsValidReverseTarget())
+            {
                 insert_node(phantom_node.reverse_segment_id.id,
                             phantom_node.GetReverseWeightPlusOffset(),
                             phantom_node.GetReverseDuration());
+            }
         }
     }
 
@@ -364,7 +356,127 @@ std::vector<EdgeDuration> oneToManySearch(SearchEngineData<Algorithm> &engine_wo
                                       phantom_indices);
     }
 
-    return durations;
+    if (calculate_distance)
+    {
+        // Initialize unpacking heaps
+        engine_working_data.InitializeOrClearFirstThreadLocalStorage(
+            facade.GetNumberOfNodes(), facade.GetMaxBorderNodeID() + 1);
+
+        distances_table.resize(phantom_indices.size(), INVALID_EDGE_DISTANCE);
+
+        for (unsigned location = 0; location < phantom_indices.size(); ++location)
+        {
+            // Get the "middle" node that is the last node of a path
+            const NodeID middle_node_id = middle_nodes_table[location];
+            if (middle_node_id == SPECIAL_NODEID) // takes care of one-ways
+            {
+                continue;
+            }
+
+            // Retrieve the packed path from the heap
+            PackedPath packed_path = mld::retrievePackedPathFromSingleManyToManyHeap<DIRECTION>(
+                query_heap, middle_node_id);
+
+            // ... and reverse it to have packed edges in the correct order,
+            if (DIRECTION == FORWARD_DIRECTION)
+            {
+                std::reverse(packed_path.begin(), packed_path.end());
+            }
+
+            // ... unpack path
+            auto &forward_heap = *engine_working_data.forward_heap_1;
+            auto &reverse_heap = *engine_working_data.reverse_heap_1;
+            EdgeWeight weight = INVALID_EDGE_WEIGHT;
+            std::vector<NodeID> unpacked_nodes;
+            std::vector<EdgeID> unpacked_edges;
+
+            std::tie(weight, unpacked_nodes, unpacked_edges) =
+                unpackPathAndCalculateDistance(engine_working_data,
+                                               facade,
+                                               forward_heap,
+                                               reverse_heap,
+                                               DO_NOT_FORCE_LOOPS,
+                                               DO_NOT_FORCE_LOOPS,
+                                               INVALID_EDGE_WEIGHT,
+                                               packed_path,
+                                               middle_node_id,
+                                               phantom_nodes,
+                                               phantom_index,
+                                               phantom_indices);
+
+            // Accumulate the path length without the last node
+            auto annotation = 0.0;
+
+            BOOST_ASSERT(!unpacked_nodes.empty());
+            for (auto node = unpacked_nodes.begin(), last_node = std::prev(unpacked_nodes.end());
+                 node != last_node;
+                 ++node)
+            {
+                annotation += computeEdgeDistance(facade, *node);
+            }
+
+            // ... and add negative source and positive target offsets
+            // ⚠ for REVERSE_DIRECTION original source and target phantom nodes are swapped
+            // Get source and target phantom nodes
+            // * 1-to-N: source is a single index, target is the corresponding from the indices list
+            // * N-to-1: source is the corresponding from the indices list, target is a single index
+            auto source_phantom_index = phantom_index;
+            auto target_phantom_index = phantom_indices[location];
+            if (DIRECTION == REVERSE_DIRECTION)
+            {
+                std::swap(source_phantom_index, target_phantom_index);
+            }
+            const auto &source_phantom = phantom_nodes[source_phantom_index];
+            const auto &target_phantom = phantom_nodes[target_phantom_index];
+            const NodeID source_node = unpacked_nodes.front();
+            const NodeID target_node = unpacked_nodes.back();
+
+            EdgeDistance source_offset = 0., target_offset = 0.;
+            if (source_phantom.IsValidForwardSource() &&
+                source_phantom.forward_segment_id.id == source_node)
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0
+                //       to 3
+                //       -->s               <-- subtract offset to start at source
+                //          .........       <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                source_offset = source_phantom.GetForwardDistance();
+            }
+            else if (source_phantom.IsValidReverseSource() &&
+                     source_phantom.reverse_segment_id.id == source_node)
+            {
+                //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
+                //          s<-------    <-- subtract offset to start at source
+                //       ...             <-- want this distance
+                // entry 0---1---2---3   <-- 3 is exit node
+                source_offset = source_phantom.GetReverseDistance();
+            }
+            if (target_phantom.IsValidForwardTarget() &&
+                target_phantom.forward_segment_id.id == target_node)
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0
+                //       to 3
+                //                   ++>t   <-- add offset to get to target
+                //       ................   <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                target_offset = target_phantom.GetForwardDistance();
+            }
+            else if (target_phantom.IsValidReverseTarget() &&
+                     target_phantom.reverse_segment_id.id == target_node)
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0
+                //       to 3
+                //                   <++t   <-- add offset to get from target
+                //       ................   <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                target_offset = target_phantom.GetReverseDistance();
+            }
+
+            distances_table[location] = -source_offset + annotation + target_offset;
+        }
+    }
+
+    return std::make_pair(durations, distances_table);
 }
 
 //
@@ -379,6 +491,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         const std::vector<NodeBucket> &search_space_with_buckets,
                         std::vector<EdgeWeight> &weights_table,
                         std::vector<EdgeDuration> &durations_table,
+                        std::vector<NodeID> &middle_nodes_table,
                         const PhantomNode &phantom_node)
 {
     const auto node = query_heap.DeleteMin();
@@ -415,6 +528,7 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         {
             current_weight = new_weight;
             current_duration = new_duration;
+            middle_nodes_table[location] = node;
         }
     }
 
@@ -432,9 +546,12 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
     const auto node = query_heap.DeleteMin();
     const auto target_weight = query_heap.GetKey(node);
     const auto target_duration = query_heap.GetData(node).duration;
+    const auto parent = query_heap.GetData(node).parent;
+    const auto from_clique_arc = query_heap.GetData(node).from_clique_arc;
 
     // Store settled nodes in search space bucket
-    search_space_with_buckets.emplace_back(node, column_idx, target_weight, target_duration);
+    search_space_with_buckets.emplace_back(
+        node, parent, from_clique_arc, column_idx, target_weight, target_duration);
 
     const auto &partition = facade.GetMultiLevelPartition();
     const auto maximal_level = partition.GetNumberOfLevels() - 1;
@@ -444,11 +561,225 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
 }
 
 template <bool DIRECTION>
-std::vector<EdgeDuration> manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                                           const DataFacade<Algorithm> &facade,
-                                           const std::vector<PhantomNode> &phantom_nodes,
-                                           const std::vector<std::size_t> &source_indices,
-                                           const std::vector<std::size_t> &target_indices)
+void retrievePackedPathFromSearchSpace(NodeID middle_node_id,
+                                       const unsigned column_idx,
+                                       const std::vector<NodeBucket> &search_space_with_buckets,
+                                       PackedPath &path)
+{
+    auto bucket_list = std::equal_range(search_space_with_buckets.begin(),
+                                        search_space_with_buckets.end(),
+                                        middle_node_id,
+                                        NodeBucket::ColumnCompare(column_idx));
+
+    BOOST_ASSERT_MSG(std::distance(bucket_list.first, bucket_list.second) == 1,
+                     "The pointers are not pointing to the same element.");
+
+    NodeID current_node_id = middle_node_id;
+
+    while (bucket_list.first->parent_node != current_node_id &&
+           bucket_list.first != search_space_with_buckets.end())
+    {
+        const auto parent_node_id = bucket_list.first->parent_node;
+
+        const auto from = DIRECTION == FORWARD_DIRECTION ? current_node_id : parent_node_id;
+        const auto to = DIRECTION == FORWARD_DIRECTION ? parent_node_id : current_node_id;
+        path.emplace_back(std::make_tuple(from, to, bucket_list.first->from_clique_arc));
+
+        current_node_id = parent_node_id;
+        bucket_list = std::equal_range(search_space_with_buckets.begin(),
+                                       search_space_with_buckets.end(),
+                                       current_node_id,
+                                       NodeBucket::ColumnCompare(column_idx));
+
+        BOOST_ASSERT_MSG(std::distance(bucket_list.first, bucket_list.second) == 1,
+                         "The pointers are not pointing to the same element.");
+    }
+}
+
+template <bool DIRECTION>
+void calculateDistances(typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
+                        const DataFacade<mld::Algorithm> &facade,
+                        const std::vector<PhantomNode> &phantom_nodes,
+                        const std::vector<std::size_t> &target_indices,
+                        const unsigned row_idx,
+                        const std::size_t source_index,
+                        const unsigned number_of_sources,
+                        const unsigned number_of_targets,
+                        const std::vector<NodeBucket> &search_space_with_buckets,
+                        std::vector<EdgeDistance> &distances_table,
+                        const std::vector<NodeID> &middle_nodes_table,
+                        SearchEngineData<mld::Algorithm> &engine_working_data)
+{
+    engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes(),
+                                                                 facade.GetMaxBorderNodeID() + 1);
+
+    for (unsigned column_idx = 0; column_idx < number_of_targets; ++column_idx)
+    {
+        // Step 1: Get source and target phantom nodes that were used in the bucketed search
+        auto source_phantom_index = source_index;
+        auto target_phantom_index = target_indices[column_idx];
+        const auto &source_phantom = phantom_nodes[source_phantom_index];
+        const auto &target_phantom = phantom_nodes[target_phantom_index];
+
+        const auto location = DIRECTION == FORWARD_DIRECTION
+                                  ? row_idx * number_of_targets + column_idx
+                                  : row_idx + column_idx * number_of_sources;
+
+        if (source_phantom_index == target_phantom_index)
+        {
+            distances_table[location] = 0.0;
+            continue;
+        }
+
+        NodeID middle_node_id = middle_nodes_table[location];
+
+        if (middle_node_id == SPECIAL_NODEID) // takes care of one-ways
+        {
+            distances_table[location] = INVALID_EDGE_DISTANCE;
+            continue;
+        }
+
+        // Step 2: Find path from source to middle node
+        PackedPath packed_path =
+            mld::retrievePackedPathFromSingleManyToManyHeap<DIRECTION>(query_heap, middle_node_id);
+
+        if (DIRECTION == FORWARD_DIRECTION)
+        {
+            std::reverse(packed_path.begin(), packed_path.end());
+        }
+
+        auto &forward_heap = *engine_working_data.forward_heap_1;
+        auto &reverse_heap = *engine_working_data.reverse_heap_1;
+        EdgeWeight weight = INVALID_EDGE_WEIGHT;
+        std::vector<NodeID> unpacked_nodes_from_source;
+        std::vector<EdgeID> unpacked_edges;
+        std::tie(weight, unpacked_nodes_from_source, unpacked_edges) =
+            unpackPathAndCalculateDistance(engine_working_data,
+                                           facade,
+                                           forward_heap,
+                                           reverse_heap,
+                                           DO_NOT_FORCE_LOOPS,
+                                           DO_NOT_FORCE_LOOPS,
+                                           INVALID_EDGE_WEIGHT,
+                                           packed_path,
+                                           middle_node_id,
+                                           source_phantom);
+
+        // Step 3: Find path from middle to target node
+        packed_path.clear();
+        retrievePackedPathFromSearchSpace<DIRECTION>(
+            middle_node_id, column_idx, search_space_with_buckets, packed_path);
+
+        if (DIRECTION == REVERSE_DIRECTION)
+        {
+            std::reverse(packed_path.begin(), packed_path.end());
+        }
+
+        std::vector<NodeID> unpacked_nodes_to_target;
+        std::tie(weight, unpacked_nodes_to_target, unpacked_edges) =
+            unpackPathAndCalculateDistance(engine_working_data,
+                                           facade,
+                                           forward_heap,
+                                           reverse_heap,
+                                           DO_NOT_FORCE_LOOPS,
+                                           DO_NOT_FORCE_LOOPS,
+                                           INVALID_EDGE_WEIGHT,
+                                           packed_path,
+                                           middle_node_id,
+                                           target_phantom);
+
+        if (DIRECTION == REVERSE_DIRECTION)
+        {
+            std::swap(unpacked_nodes_to_target, unpacked_nodes_from_source);
+        }
+
+        // Step 4: Compute annotation value along the path nodes without the target node
+        auto annotation = 0.0;
+
+        for (auto node = unpacked_nodes_from_source.begin(),
+                  last_node = std::prev(unpacked_nodes_from_source.end());
+             node != last_node;
+             ++node)
+        {
+            annotation += computeEdgeDistance(facade, *node);
+        }
+
+        for (auto node = unpacked_nodes_to_target.begin(),
+                  last_node = std::prev(unpacked_nodes_to_target.end());
+             node != last_node;
+             ++node)
+        {
+            annotation += computeEdgeDistance(facade, *node);
+        }
+
+        // Step 5: Get phantom node offsets and compute the annotation value
+        EdgeDistance source_offset = 0., target_offset = 0.;
+        {
+            // ⚠ for REVERSE_DIRECTION original source and target phantom nodes are swapped
+            if (DIRECTION == REVERSE_DIRECTION)
+            {
+                std::swap(source_phantom_index, target_phantom_index);
+            }
+            const auto &source_phantom = phantom_nodes[source_phantom_index];
+            const auto &target_phantom = phantom_nodes[target_phantom_index];
+
+            NodeID source_node = unpacked_nodes_from_source.front();
+            NodeID target_node = unpacked_nodes_to_target.back();
+
+            if (source_phantom.IsValidForwardSource() &&
+                source_phantom.forward_segment_id.id == source_node)
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0
+                //       to 3
+                //       -->s               <-- subtract offset to start at source
+                //          .........       <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                source_offset = source_phantom.GetForwardDistance();
+            }
+            else if (source_phantom.IsValidReverseSource() &&
+                     source_phantom.reverse_segment_id.id == source_node)
+            {
+                //       ............    <-- calculateEGBAnnotation returns distance from 0 to 3
+                //          s<-------    <-- subtract offset to start at source
+                //       ...             <-- want this distance
+                // entry 0---1---2---3   <-- 3 is exit node
+                source_offset = source_phantom.GetReverseDistance();
+            }
+
+            if (target_phantom.IsValidForwardTarget() &&
+                target_phantom.forward_segment_id.id == target_node)
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0
+                //       to 3
+                //                   ++>t   <-- add offset to get to target
+                //       ................   <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                target_offset = target_phantom.GetForwardDistance();
+            }
+            else if (target_phantom.IsValidReverseTarget() &&
+                     target_phantom.reverse_segment_id.id == target_node)
+            {
+                //       ............       <-- calculateEGBAnnotation returns distance from 0
+                //       to 3
+                //                   <++t   <-- add offset to get from target
+                //       ................   <-- want this distance as result
+                // entry 0---1---2---3---   <-- 3 is exit node
+                target_offset = target_phantom.GetReverseDistance();
+            }
+        }
+
+        distances_table[location] = -source_offset + annotation + target_offset;
+    }
+}
+
+template <bool DIRECTION>
+std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
+manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
+                 const DataFacade<Algorithm> &facade,
+                 const std::vector<PhantomNode> &phantom_nodes,
+                 const std::vector<std::size_t> &source_indices,
+                 const std::vector<std::size_t> &target_indices,
+                 const bool calculate_distance)
 {
     const auto number_of_sources = source_indices.size();
     const auto number_of_targets = target_indices.size();
@@ -456,6 +787,8 @@ std::vector<EdgeDuration> manyToManySearch(SearchEngineData<Algorithm> &engine_w
 
     std::vector<EdgeWeight> weights_table(number_of_entries, INVALID_EDGE_WEIGHT);
     std::vector<EdgeDuration> durations_table(number_of_entries, MAXIMAL_EDGE_DURATION);
+    std::vector<EdgeDistance> distances_table;
+    std::vector<NodeID> middle_nodes_table(number_of_entries, SPECIAL_NODEID);
 
     std::vector<NodeBucket> search_space_with_buckets;
 
@@ -463,22 +796,22 @@ std::vector<EdgeDuration> manyToManySearch(SearchEngineData<Algorithm> &engine_w
     for (std::uint32_t column_idx = 0; column_idx < target_indices.size(); ++column_idx)
     {
         const auto index = target_indices[column_idx];
-        const auto &phantom = phantom_nodes[index];
+        const auto &target_phantom = phantom_nodes[index];
 
         engine_working_data.InitializeOrClearManyToManyThreadLocalStorage(
             facade.GetNumberOfNodes(), facade.GetMaxBorderNodeID() + 1);
         auto &query_heap = *(engine_working_data.many_to_many_heap);
 
         if (DIRECTION == FORWARD_DIRECTION)
-            insertTargetInHeap(query_heap, phantom);
+            insertTargetInHeap(query_heap, target_phantom);
         else
-            insertSourceInHeap(query_heap, phantom);
+            insertSourceInHeap(query_heap, target_phantom);
 
         // explore search space
         while (!query_heap.Empty())
         {
             backwardRoutingStep<DIRECTION>(
-                facade, column_idx, query_heap, search_space_with_buckets, phantom);
+                facade, column_idx, query_heap, search_space_with_buckets, target_phantom);
         }
     }
 
@@ -488,18 +821,19 @@ std::vector<EdgeDuration> manyToManySearch(SearchEngineData<Algorithm> &engine_w
     // Find shortest paths from sources to all accessible nodes
     for (std::uint32_t row_idx = 0; row_idx < source_indices.size(); ++row_idx)
     {
-        const auto index = source_indices[row_idx];
-        const auto &phantom = phantom_nodes[index];
+        const auto source_index = source_indices[row_idx];
+        const auto &source_phantom = phantom_nodes[source_index];
 
         // Clear heap and insert source nodes
         engine_working_data.InitializeOrClearManyToManyThreadLocalStorage(
             facade.GetNumberOfNodes(), facade.GetMaxBorderNodeID() + 1);
+
         auto &query_heap = *(engine_working_data.many_to_many_heap);
 
         if (DIRECTION == FORWARD_DIRECTION)
-            insertSourceInHeap(query_heap, phantom);
+            insertSourceInHeap(query_heap, source_phantom);
         else
-            insertTargetInHeap(query_heap, phantom);
+            insertTargetInHeap(query_heap, source_phantom);
 
         // Explore search space
         while (!query_heap.Empty())
@@ -512,11 +846,29 @@ std::vector<EdgeDuration> manyToManySearch(SearchEngineData<Algorithm> &engine_w
                                           search_space_with_buckets,
                                           weights_table,
                                           durations_table,
-                                          phantom);
+                                          middle_nodes_table,
+                                          source_phantom);
+        }
+
+        if (calculate_distance)
+        {
+            distances_table.resize(number_of_entries, INVALID_EDGE_DISTANCE);
+            calculateDistances<DIRECTION>(query_heap,
+                                          facade,
+                                          phantom_nodes,
+                                          target_indices, // source_indices
+                                          row_idx,
+                                          source_index,
+                                          number_of_sources,
+                                          number_of_targets,
+                                          search_space_with_buckets,
+                                          distances_table,
+                                          middle_nodes_table,
+                                          engine_working_data);
         }
     }
 
-    return durations_table;
+    return std::make_pair(durations_table, distances_table);
 }
 
 } // namespace mld
@@ -534,32 +886,54 @@ std::vector<EdgeDuration> manyToManySearch(SearchEngineData<Algorithm> &engine_w
 //   then search is performed on a reversed graph with phantom nodes with flipped roles and
 //   returning a transposed matrix.
 template <>
-std::vector<EdgeDuration> manyToManySearch(SearchEngineData<mld::Algorithm> &engine_working_data,
-                                           const DataFacade<mld::Algorithm> &facade,
-                                           const std::vector<PhantomNode> &phantom_nodes,
-                                           const std::vector<std::size_t> &source_indices,
-                                           const std::vector<std::size_t> &target_indices)
+std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>>
+manyToManySearch(SearchEngineData<mld::Algorithm> &engine_working_data,
+                 const DataFacade<mld::Algorithm> &facade,
+                 const std::vector<PhantomNode> &phantom_nodes,
+                 const std::vector<std::size_t> &source_indices,
+                 const std::vector<std::size_t> &target_indices,
+                 const bool calculate_distance,
+                 const bool calculate_duration)
 {
+    (void)calculate_duration; // flag stub to use for calculating distances in matrix in mld in the
+                              // future
+
     if (source_indices.size() == 1)
     { // TODO: check if target_indices.size() == 1 and do a bi-directional search
-        return mld::oneToManySearch<FORWARD_DIRECTION>(
-            engine_working_data, facade, phantom_nodes, source_indices.front(), target_indices);
+        return mld::oneToManySearch<FORWARD_DIRECTION>(engine_working_data,
+                                                       facade,
+                                                       phantom_nodes,
+                                                       source_indices.front(),
+                                                       target_indices,
+                                                       calculate_distance);
     }
 
     if (target_indices.size() == 1)
     {
-        return mld::oneToManySearch<REVERSE_DIRECTION>(
-            engine_working_data, facade, phantom_nodes, target_indices.front(), source_indices);
+        return mld::oneToManySearch<REVERSE_DIRECTION>(engine_working_data,
+                                                       facade,
+                                                       phantom_nodes,
+                                                       target_indices.front(),
+                                                       source_indices,
+                                                       calculate_distance);
     }
 
     if (target_indices.size() < source_indices.size())
     {
-        return mld::manyToManySearch<REVERSE_DIRECTION>(
-            engine_working_data, facade, phantom_nodes, target_indices, source_indices);
+        return mld::manyToManySearch<REVERSE_DIRECTION>(engine_working_data,
+                                                        facade,
+                                                        phantom_nodes,
+                                                        target_indices,
+                                                        source_indices,
+                                                        calculate_distance);
     }
 
-    return mld::manyToManySearch<FORWARD_DIRECTION>(
-        engine_working_data, facade, phantom_nodes, source_indices, target_indices);
+    return mld::manyToManySearch<FORWARD_DIRECTION>(engine_working_data,
+                                                    facade,
+                                                    phantom_nodes,
+                                                    source_indices,
+                                                    target_indices,
+                                                    calculate_distance);
 }
 
 } // namespace routing_algorithms
diff --git a/src/engine/routing_algorithms/routing_base_ch.cpp b/src/engine/routing_algorithms/routing_base_ch.cpp
index 4bdd0a73c18..695ebe9234a 100644
--- a/src/engine/routing_algorithms/routing_base_ch.cpp
+++ b/src/engine/routing_algorithms/routing_base_ch.cpp
@@ -59,6 +59,24 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
     }
 }
 
+void retrievePackedPathFromSingleManyToManyHeap(
+    const SearchEngineData<Algorithm>::ManyToManyQueryHeap &search_heap,
+    const NodeID middle_node_id,
+    std::vector<NodeID> &packed_path)
+{
+    NodeID current_node_id = middle_node_id;
+    // all initial nodes will have itself as parent, or a node not in the heap
+    // in case of a core search heap. We need a distinction between core entry nodes
+    // and start nodes since otherwise start node specific code that assumes
+    // node == node.parent (e.g. the loop code) might get actived.
+    while (current_node_id != search_heap.GetData(current_node_id).parent &&
+           search_heap.WasInserted(search_heap.GetData(current_node_id).parent))
+    {
+        current_node_id = search_heap.GetData(current_node_id).parent;
+        packed_path.emplace_back(current_node_id);
+    }
+}
+
 // assumes that heaps are already setup correctly.
 // ATTENTION: This only works if no additional offset is supplied next to the Phantom Node
 // Offsets.
diff --git a/src/engine/routing_algorithms/tile_turns.cpp b/src/engine/routing_algorithms/tile_turns.cpp
index 17ea540e3df..d8d28523d22 100644
--- a/src/engine/routing_algorithms/tile_turns.cpp
+++ b/src/engine/routing_algorithms/tile_turns.cpp
@@ -101,7 +101,6 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
     //         w
     //  uv is the "approach"
     //  vw is the "exit"
-
     // Look at every node in the directed graph we created
     for (const auto &startnode : sorted_startnodes)
     {
@@ -146,42 +145,8 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
                     const auto &data = facade.GetEdgeData(edge_based_edge_id);
 
                     // Now, calculate the sum of the weight of all the segments.
-                    const auto &geometry =
-                        edge_based_node_info.find(approachedge.edge_based_node_id)->second;
-                    EdgeWeight sum_node_weight = 0;
-                    EdgeDuration sum_node_duration = 0;
-                    if (geometry.is_geometry_forward)
-                    {
-                        const auto approach_weight =
-                            facade.GetUncompressedForwardWeights(geometry.packed_geometry_id);
-                        const auto approach_duration =
-                            facade.GetUncompressedForwardDurations(geometry.packed_geometry_id);
-                        sum_node_weight = std::accumulate(
-                            approach_weight.begin(), approach_weight.end(), EdgeWeight{0});
-                        sum_node_duration = std::accumulate(
-                            approach_duration.begin(), approach_duration.end(), EdgeDuration{0});
-                    }
-                    else
-                    {
-                        const auto approach_weight =
-                            facade.GetUncompressedReverseWeights(geometry.packed_geometry_id);
-                        const auto approach_duration =
-                            facade.GetUncompressedReverseDurations(geometry.packed_geometry_id);
-                        sum_node_weight = std::accumulate(
-                            approach_weight.begin(), approach_weight.end(), EdgeWeight{0});
-                        sum_node_duration = std::accumulate(
-                            approach_duration.begin(), approach_duration.end(), EdgeDuration{0});
-                    }
-
-                    // The edge.weight is the whole edge weight, which includes the turn
-                    // cost.
-                    // The turn cost is the edge.weight minus the sum of the individual road
-                    // segment weights.  This might not be 100% accurate, because some
-                    // intersections include stop signs, traffic signals and other
-                    // penalties, but at this stage, we can't divide those out, so we just
-                    // treat the whole lot as the "turn cost" that we'll stick on the map.
-                    const auto turn_weight = data.weight - sum_node_weight;
-                    const auto turn_duration = data.duration - sum_node_duration;
+                    const auto turn_weight = facade.GetWeightPenaltyForEdgeID(data.turn_id);
+                    const auto turn_duration = facade.GetDurationPenaltyForEdgeID(data.turn_id);
                     const auto turn_instruction = facade.GetTurnInstructionForEdgeID(data.turn_id);
 
                     // Find the three nodes that make up the turn movement)
diff --git a/src/extractor/edge_based_graph_factory.cpp b/src/extractor/edge_based_graph_factory.cpp
index 2db06188b9c..8d77e20743d 100644
--- a/src/extractor/edge_based_graph_factory.cpp
+++ b/src/extractor/edge_based_graph_factory.cpp
@@ -107,6 +107,13 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &out
     swap(m_edge_based_node_weights, output_node_weights);
 }
 
+void EdgeBasedGraphFactory::GetEdgeBasedNodeDurations(
+    std::vector<EdgeWeight> &output_node_durations)
+{
+    using std::swap; // Koenig swap
+    swap(m_edge_based_node_durations, output_node_durations);
+}
+
 std::uint32_t EdgeBasedGraphFactory::GetConnectivityChecksum() const
 {
     return m_connectivity_checksum;
@@ -138,9 +145,16 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
     BOOST_ASSERT(nbe_to_ebn_mapping[edge_id_1] != SPECIAL_NODEID ||
                  nbe_to_ebn_mapping[edge_id_2] != SPECIAL_NODEID);
 
+    // ⚠ Use the sign bit of node weights to distinguish oneway streets:
+    //  * MSB is set - a node corresponds to a one-way street
+    //  * MSB is clear - a node corresponds to a bidirectional street
+    // Before using node weights data values must be adjusted:
+    //  * in contraction if MSB is set the node weight is INVALID_EDGE_WEIGHT.
+    //    This adjustment is needed to enforce loop creation for oneways.
+    //  * in other cases node weights must be masked with 0x7fffffff to clear MSB
     if (nbe_to_ebn_mapping[edge_id_1] != SPECIAL_NODEID &&
         nbe_to_ebn_mapping[edge_id_2] == SPECIAL_NODEID)
-        m_edge_based_node_weights[nbe_to_ebn_mapping[edge_id_1]] = INVALID_EDGE_WEIGHT;
+        m_edge_based_node_weights[nbe_to_ebn_mapping[edge_id_1]] |= 0x80000000;
 
     BOOST_ASSERT(m_compressed_edge_container.HasEntryForID(edge_id_1) ==
                  m_compressed_edge_container.HasEntryForID(edge_id_2));
@@ -278,6 +292,7 @@ unsigned EdgeBasedGraphFactory::LabelEdgeBasedNodes()
     // heuristic: node-based graph node is a simple intersection with four edges
     // (edge-based nodes)
     m_edge_based_node_weights.reserve(4 * m_node_based_graph.GetNumberOfNodes());
+    m_edge_based_node_durations.reserve(4 * m_node_based_graph.GetNumberOfNodes());
     nbe_to_ebn_mapping.resize(m_node_based_graph.GetEdgeCapacity(), SPECIAL_NODEID);
 
     // renumber edge based node of outgoing edges
@@ -294,6 +309,7 @@ unsigned EdgeBasedGraphFactory::LabelEdgeBasedNodes()
             }
 
             m_edge_based_node_weights.push_back(edge_data.weight);
+            m_edge_based_node_durations.push_back(edge_data.duration);
 
             BOOST_ASSERT(numbered_edges_count < m_node_based_graph.GetNumberOfEdges());
             nbe_to_ebn_mapping[current_edge] = numbered_edges_count;
@@ -387,8 +403,10 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
                 segregated_edges.count(eid) > 0;
 
             const auto ebn_weight = m_edge_based_node_weights[nbe_to_ebn_mapping[eid]];
-            BOOST_ASSERT(ebn_weight == INVALID_EDGE_WEIGHT || ebn_weight == edge_data.weight);
+            BOOST_ASSERT((ebn_weight & 0x7fffffff) == edge_data.weight);
             m_edge_based_node_weights.push_back(ebn_weight);
+            m_edge_based_node_durations.push_back(
+                m_edge_based_node_durations[nbe_to_ebn_mapping[eid]]);
 
             edge_based_node_id++;
             progress.PrintStatus(progress_counter++);
@@ -397,6 +415,7 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
 
     BOOST_ASSERT(m_edge_based_node_segments.size() == m_edge_based_node_is_startpoint.size());
     BOOST_ASSERT(m_number_of_edge_based_nodes == m_edge_based_node_weights.size());
+    BOOST_ASSERT(m_number_of_edge_based_nodes == m_edge_based_node_durations.size());
 
     util::Log() << "Generated " << m_number_of_edge_based_nodes << " nodes ("
                 << way_restriction_map.NumberOfDuplicatedNodes()
diff --git a/src/extractor/extractor.cpp b/src/extractor/extractor.cpp
index 064fc59d055..f62bb1b39cc 100644
--- a/src/extractor/extractor.cpp
+++ b/src/extractor/extractor.cpp
@@ -241,6 +241,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
     util::DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
     std::vector<bool> node_is_startpoint;
     std::vector<EdgeWeight> edge_based_node_weights;
+    std::vector<EdgeDuration> edge_based_node_durations;
     std::uint32_t ebg_connectivity_checksum = 0;
 
     // Create a node-based graph from the OSRM file
@@ -320,6 +321,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
                                edge_based_node_segments,
                                node_is_startpoint,
                                edge_based_node_weights,
+                               edge_based_node_durations,
                                edge_based_edge_list,
                                ebg_connectivity_checksum);
 
@@ -343,8 +345,8 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
 
     util::Log() << "Saving edge-based node weights to file.";
     TIMER_START(timer_write_node_weights);
-    extractor::files::writeEdgeBasedNodeWeights(config.GetPath(".osrm.enw"),
-                                                edge_based_node_weights);
+    extractor::files::writeEdgeBasedNodeWeightsDurations(
+        config.GetPath(".osrm.enw"), edge_based_node_weights, edge_based_node_durations);
     TIMER_STOP(timer_write_node_weights);
     util::Log() << "Done writing. (" << TIMER_SEC(timer_write_node_weights) << ")";
 
@@ -733,6 +735,7 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
     std::vector<EdgeBasedNodeSegment> &edge_based_node_segments,
     std::vector<bool> &node_is_startpoint,
     std::vector<EdgeWeight> &edge_based_node_weights,
+    std::vector<EdgeDuration> &edge_based_node_durations,
     util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
     std::uint32_t &connectivity_checksum)
 {
@@ -782,6 +785,7 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
     edge_based_graph_factory.GetEdgeBasedNodeSegments(edge_based_node_segments);
     edge_based_graph_factory.GetStartPointMarkers(node_is_startpoint);
     edge_based_graph_factory.GetEdgeBasedNodeWeights(edge_based_node_weights);
+    edge_based_graph_factory.GetEdgeBasedNodeDurations(edge_based_node_durations);
     connectivity_checksum = edge_based_graph_factory.GetConnectivityChecksum();
 
     return number_of_edge_based_nodes;
diff --git a/src/nodejs/node_osrm.cpp b/src/nodejs/node_osrm.cpp
index e98e251d28a..aa7e03851f6 100644
--- a/src/nodejs/node_osrm.cpp
+++ b/src/nodejs/node_osrm.cpp
@@ -263,7 +263,7 @@ NAN_METHOD(Engine::nearest) //
 
 // clang-format off
 /**
- * Computes duration tables for the given locations. Allows for both symmetric and asymmetric
+ * Computes duration and distance tables for the given locations. Allows for both symmetric and asymmetric
  * tables.
  *
  * @name table
@@ -274,17 +274,20 @@ NAN_METHOD(Engine::nearest) //
  *                                   Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
  * @param {Array} [options.radiuses] Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
  * @param {Array} [options.hints] Hints for the coordinate snapping. Array of base64 encoded strings.
- * @param {Array} [options.sources] An array of `index` elements (`0 <= integer < #coordinates`) to
- * use
- * location with given index as source. Default is to use all.
- * @param {Array} [options.destinations] An array of `index` elements (`0 <= integer <
- * #coordinates`) to use location with given index as destination. Default is to use all.
+ * @param {Array} [options.sources] An array of `index` elements (`0 <= integer < #coordinates`) to use
+ *                                  location with given index as source. Default is to use all.
+ * @param {Array} [options.destinations] An array of `index` elements (`0 <= integer < #coordinates`) to use location with given index as destination. Default is to use all.
  * @param {Array} [options.approaches] Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+ * @param {Array} [options.annotations] An array of the table types to return. Values can be `duration` or `distance` or both. If no annotations parameter is added, the default is to return the `durations` table. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
+
  * @param {Function} callback
  *
  * @returns {Object} containing `durations`, `sources`, and `destinations`.
  * **`durations`**: array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
  *                  Values are given in seconds.
+ * **`distances`**: array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
+ *                  Values are given in meters. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or
+ *                  `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
  * **`sources`**: array of [`Ẁaypoint`](#waypoint) objects describing all sources in order.
  * **`destinations`**: array of [`Ẁaypoint`](#waypoint) objects describing all destinations in order.
  *
@@ -299,6 +302,7 @@ NAN_METHOD(Engine::nearest) //
  * };
  * osrm.table(options, function(err, response) {
  *   console.log(response.durations); // array of arrays, matrix in row-major order
+ *   console.log(response.distances); // array of arrays, matrix in row-major order (currently only implemented for CH router)
  *   console.log(response.sources); // array of Waypoint objects
  *   console.log(response.destinations); // array of Waypoint objects
  * });
diff --git a/src/partitioner/partitioner.cpp b/src/partitioner/partitioner.cpp
index 06fa87c5d3a..c180893863e 100644
--- a/src/partitioner/partitioner.cpp
+++ b/src/partitioner/partitioner.cpp
@@ -144,6 +144,16 @@ int Partitioner::Run(const PartitionerConfig &config)
         renumber(node_data, permutation);
         extractor::files::writeNodeData(config.GetPath(".osrm.ebg_nodes"), node_data);
     }
+    {
+        std::vector<EdgeWeight> node_weights;
+        std::vector<EdgeDuration> node_durations;
+        extractor::files::readEdgeBasedNodeWeightsDurations(
+            config.GetPath(".osrm.enw"), node_weights, node_durations);
+        util::inplacePermutation(node_weights.begin(), node_weights.end(), permutation);
+        util::inplacePermutation(node_durations.begin(), node_durations.end(), permutation);
+        extractor::files::writeEdgeBasedNodeWeightsDurations(
+            config.GetPath(".osrm.enw"), node_weights, node_durations);
+    }
     {
         const auto &filename = config.GetPath(".osrm.maneuver_overrides");
         std::vector<extractor::StorageManeuverOverride> maneuver_overrides;
diff --git a/src/storage/storage.cpp b/src/storage/storage.cpp
index 7ae6937398b..bcdf0325291 100644
--- a/src/storage/storage.cpp
+++ b/src/storage/storage.cpp
@@ -554,7 +554,7 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
     {
         auto graph_view = make_multi_level_graph_view(index, "/mld/multilevelgraph");
         std::uint32_t graph_connectivity_checksum = 0;
-        partitioner::files::readGraph(
+        customizer::files::readGraph(
             config.GetPath(".osrm.mldgr"), graph_view, graph_connectivity_checksum);
 
         auto turns_connectivity_checksum =
diff --git a/src/tools/store.cpp b/src/tools/store.cpp
index 5755e77dd66..cf9d965264d 100644
--- a/src/tools/store.cpp
+++ b/src/tools/store.cpp
@@ -1,6 +1,8 @@
+#include "storage/serialization.hpp"
 #include "storage/shared_memory.hpp"
 #include "storage/shared_monitor.hpp"
 #include "storage/storage.hpp"
+
 #include "osrm/exception.hpp"
 #include "util/log.hpp"
 #include "util/meminfo.hpp"
@@ -25,7 +27,7 @@ void deleteRegion(const storage::SharedRegionRegister::ShmKey key)
     }
 }
 
-void listRegions()
+void listRegions(bool show_blocks)
 {
     osrm::util::Log() << "name\tshm key\ttimestamp\tsize";
     if (!storage::SharedMonitor<storage::SharedRegionRegister>::exists())
@@ -43,6 +45,23 @@ void listRegions()
         auto shm = osrm::storage::makeSharedMemory(region.shm_key);
         osrm::util::Log() << name << "\t" << static_cast<int>(region.shm_key) << "\t"
                           << region.timestamp << "\t" << shm->Size();
+
+        if (show_blocks)
+        {
+            using namespace storage;
+            auto memory = makeSharedMemory(region.shm_key);
+            io::BufferReader reader(reinterpret_cast<char *>(memory->Ptr()), memory->Size());
+
+            DataLayout layout;
+            serialization::read(reader, layout);
+
+            std::vector<std::string> block_names;
+            layout.List("", std::back_inserter(block_names));
+            for (auto &name : block_names)
+            {
+                osrm::util::Log() << "  " << name << " " << layout.GetBlockSize(name);
+            }
+        }
     }
 }
 
@@ -79,6 +98,7 @@ bool generateDataStoreOptions(const int argc,
                               int &max_wait,
                               std::string &dataset_name,
                               bool &list_datasets,
+                              bool &list_blocks,
                               bool &only_metric)
 {
     // declare a group of options that will be allowed only on command line
@@ -109,12 +129,18 @@ bool generateDataStoreOptions(const int argc,
              ->default_value(false)
              ->implicit_value(true),
          "List all OSRM datasets currently in memory") //
-        ("only-metric",
-         boost::program_options::value<bool>(&only_metric)
+        ("list-blocks",
+         boost::program_options::value<bool>(&list_blocks)
              ->default_value(false)
              ->implicit_value(true),
-         "Only reload the metric data without updating the full dataset. This is an optimization "
-         "for traffic updates.");
+         "List all OSRM datasets currently in memory")(
+            "only-metric",
+            boost::program_options::value<bool>(&only_metric)
+                ->default_value(false)
+                ->implicit_value(true),
+            "Only reload the metric data without updating the full dataset. This is an "
+            "optimization "
+            "for traffic updates.");
 
     // hidden options, will be allowed on command line but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");
@@ -209,18 +235,26 @@ int main(const int argc, const char *argv[]) try
     int max_wait = -1;
     std::string dataset_name;
     bool list_datasets = false;
+    bool list_blocks = false;
     bool only_metric = false;
-    if (!generateDataStoreOptions(
-            argc, argv, verbosity, base_path, max_wait, dataset_name, list_datasets, only_metric))
+    if (!generateDataStoreOptions(argc,
+                                  argv,
+                                  verbosity,
+                                  base_path,
+                                  max_wait,
+                                  dataset_name,
+                                  list_datasets,
+                                  list_blocks,
+                                  only_metric))
     {
         return EXIT_SUCCESS;
     }
 
     util::LogPolicy::GetInstance().SetLevel(verbosity);
 
-    if (list_datasets)
+    if (list_datasets || list_blocks)
     {
-        listRegions();
+        listRegions(list_blocks);
         return EXIT_SUCCESS;
     }
 
diff --git a/src/updater/updater.cpp b/src/updater/updater.cpp
index b9e5356fc3b..f4dc902a3e6 100644
--- a/src/updater/updater.cpp
+++ b/src/updater/updater.cpp
@@ -517,7 +517,6 @@ updateConditionalTurns(std::vector<TurnPenalty> &turn_weight_penalties,
     {
         if (IsRestrictionValid(time_zone_handler, penalty))
         {
-            std::cout << "Disabling: " << penalty.turn_offset << std::endl;
             turn_weight_penalties[penalty.turn_offset] = INVALID_TURN_PENALTY;
             updated_turns.push_back(penalty.turn_offset);
         }
@@ -526,20 +525,20 @@ updateConditionalTurns(std::vector<TurnPenalty> &turn_weight_penalties,
 }
 }
 
-Updater::NumNodesAndEdges Updater::LoadAndUpdateEdgeExpandedGraph() const
+EdgeID
+Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
+                                        std::vector<EdgeWeight> &node_weights,
+                                        std::uint32_t &connectivity_checksum) const
 {
-    std::vector<EdgeWeight> node_weights;
-    std::vector<extractor::EdgeBasedEdge> edge_based_edge_list;
-    std::uint32_t connectivity_checksum;
-    auto number_of_edge_based_nodes = Updater::LoadAndUpdateEdgeExpandedGraph(
-        edge_based_edge_list, node_weights, connectivity_checksum);
-    return std::make_tuple(
-        number_of_edge_based_nodes, std::move(edge_based_edge_list), connectivity_checksum);
+    std::vector<EdgeDuration> node_durations(node_weights.size());
+    return LoadAndUpdateEdgeExpandedGraph(
+        edge_based_edge_list, node_weights, node_durations, connectivity_checksum);
 }
 
 EdgeID
 Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
                                         std::vector<EdgeWeight> &node_weights,
+                                        std::vector<EdgeDuration> &node_durations,
                                         std::uint32_t &connectivity_checksum) const
 {
     TIMER_START(load_edges);
@@ -548,6 +547,9 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
     std::vector<util::Coordinate> coordinates;
     extractor::PackedOSMIDs osm_node_ids;
 
+    extractor::files::readEdgeBasedNodeWeightsDurations(
+        config.GetPath(".osrm.enw"), node_weights, node_durations);
+
     extractor::files::readEdgeBasedGraph(config.GetPath(".osrm.ebg"),
                                          number_of_edge_based_nodes,
                                          edge_based_edge_list,
@@ -743,12 +745,12 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
                 accumulated_segment_data[updated_iter - updated_segments.begin()];
 
             // Update the node-weight cache. This is the weight of the edge-based-node
-            // only,
-            // it doesn't include the turn. We may visit the same node multiple times,
-            // but
-            // we should always assign the same value here.
-            if (node_weights.size() > 0)
-                node_weights[edge.source] = new_weight;
+            // only, it doesn't include the turn. We may visit the same node multiple times,
+            // but we should always assign the same value here.
+            BOOST_ASSERT(edge.source < node_weights.size());
+            node_weights[edge.source] =
+                node_weights[edge.source] & 0x80000000 ? new_weight | 0x80000000 : new_weight;
+            node_durations[edge.source] = new_duration;
 
             // We found a zero-speed edge, so we'll skip this whole edge-based-edge
             // which
diff --git a/src/util/coordinate_calculation.cpp b/src/util/coordinate_calculation.cpp
index ae968203d73..cb9adb10a9b 100644
--- a/src/util/coordinate_calculation.cpp
+++ b/src/util/coordinate_calculation.cpp
@@ -5,6 +5,8 @@
 
 #include <boost/assert.hpp>
 
+#include <mapbox/cheap_ruler.hpp>
+
 #include <algorithm>
 #include <iterator>
 #include <limits>
@@ -18,6 +20,44 @@ namespace util
 namespace coordinate_calculation
 {
 
+namespace
+{
+class CheapRulerContainer
+{
+  public:
+    CheapRulerContainer(const int number_of_rulers)
+        : cheap_ruler_cache(number_of_rulers, mapbox::cheap_ruler::CheapRuler(0)),
+          step(90.0 * COORDINATE_PRECISION / number_of_rulers)
+    {
+        for (int n = 0; n < number_of_rulers; n++)
+        {
+            cheap_ruler_cache[n] = mapbox::cheap_ruler::CheapRuler(
+                step * (n + 0.5) / COORDINATE_PRECISION, mapbox::cheap_ruler::CheapRuler::Meters);
+        }
+    };
+
+    mapbox::cheap_ruler::CheapRuler &getRuler(const FixedLatitude lat_1, const FixedLatitude lat_2)
+    {
+        auto lat = (lat_1 + lat_2) / util::FixedLatitude{2};
+        return getRuler(lat);
+    }
+
+    mapbox::cheap_ruler::CheapRuler &getRuler(const FixedLatitude lat)
+    {
+        BOOST_ASSERT(step > 2);
+        // the |lat| > 0  ->  |lat|-1 > -1  ->  (|lat|-1)/step > -1/step > -1/2 >= -1  ->  bin >= 0
+        std::size_t bin = (std::abs(static_cast<int>(lat)) - 1) / step;
+        BOOST_ASSERT(bin < cheap_ruler_cache.size());
+        return cheap_ruler_cache[bin];
+    };
+
+  private:
+    std::vector<mapbox::cheap_ruler::CheapRuler> cheap_ruler_cache;
+    const int step;
+};
+static CheapRulerContainer cheap_ruler_container(1800);
+} // namespace
+
 // Does not project the coordinates!
 std::uint64_t squaredEuclideanDistance(const Coordinate lhs, const Coordinate rhs)
 {
@@ -32,6 +72,20 @@ std::uint64_t squaredEuclideanDistance(const Coordinate lhs, const Coordinate rh
     return result;
 }
 
+// Uses method described here:
+// https://www.gpo.gov/fdsys/pkg/CFR-2005-title47-vol4/pdf/CFR-2005-title47-vol4-sec73-208.pdf
+// should be within 0.1% or so of Vincenty method (assuming 19 buckets are enough)
+// Should be more faster and more precise than Haversine
+double fccApproximateDistance(const Coordinate coordinate_1, const Coordinate coordinate_2)
+{
+    const auto lon1 = static_cast<double>(util::toFloating(coordinate_1.lon));
+    const auto lat1 = static_cast<double>(util::toFloating(coordinate_1.lat));
+    const auto lon2 = static_cast<double>(util::toFloating(coordinate_2.lon));
+    const auto lat2 = static_cast<double>(util::toFloating(coordinate_2.lat));
+    return cheap_ruler_container.getRuler(coordinate_1.lat, coordinate_2.lat)
+        .distance({lon1, lat1}, {lon2, lat2});
+}
+
 double haversineDistance(const Coordinate coordinate_1, const Coordinate coordinate_2)
 {
     auto lon1 = static_cast<int>(coordinate_1.lon);
@@ -423,6 +477,6 @@ double computeArea(const std::vector<Coordinate> &polygon)
     return area / 2.;
 }
 
-} // ns coordinate_calculation
-} // ns util
-} // ns osrm
+} // namespace coordinate_calculation
+} // namespace util
+} // namespace osrm
diff --git a/test/nodejs/constants.js b/test/nodejs/constants.js
index bd3c454cb55..0726bc91c3d 100644
--- a/test/nodejs/constants.js
+++ b/test/nodejs/constants.js
@@ -10,7 +10,7 @@ exports.three_test_coordinates = [[7.41337, 43.72956],
 
 exports.two_test_coordinates = exports.three_test_coordinates.slice(0, 2)
 
-exports.test_tile = {'at': [17059, 11948, 15], 'size': 168571};
+exports.test_tile = {'at': [17059, 11948, 15], 'size': 148750};
 
 // Test files generated by the routing engine; check test/data
 if (process.env.OSRM_DATA_PATH !== undefined) {
diff --git a/test/nodejs/table.js b/test/nodejs/table.js
index 972550614d4..220added1b0 100644
--- a/test/nodejs/table.js
+++ b/test/nodejs/table.js
@@ -5,179 +5,228 @@ var mld_data_path = require('./constants').mld_data_path;
 var three_test_coordinates = require('./constants').three_test_coordinates;
 var two_test_coordinates = require('./constants').two_test_coordinates;
 
-
-test('table: distance table in Monaco', function(assert) {
-    assert.plan(11);
+test('table: test annotations paramater combination', function(assert) {
+    assert.plan(12);
     var osrm = new OSRM(data_path);
     var options = {
-        coordinates: [three_test_coordinates[0], three_test_coordinates[1]]
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
+        annotations: ['distance']
     };
     osrm.table(options, function(err, table) {
         assert.ifError(err);
-        assert.ok(Array.isArray(table.durations), 'result must be an array');
-        var row_count = table.durations.length;
-        for (var i = 0; i < row_count; ++i) {
-            var column = table.durations[i];
-            var column_count = column.length;
-            assert.equal(row_count, column_count);
-            for (var j = 0; j < column_count; ++j) {
-                if (i == j) {
-                    // check that diagonal is zero
-                    assert.equal(0, column[j], 'diagonal must be zero');
-                } else {
-                    // everything else is non-zero
-                    assert.notEqual(0, column[j], 'other entries must be non-zero');
-                    // and finite (not nan, inf etc.)
-                    assert.ok(Number.isFinite(column[j]), 'distance is finite number');
-                }
-            }
-        }
-        assert.equal(options.coordinates.length, row_count);
+        assert.ok(table['distances'], 'distances table result should exist');
+        assert.notOk(table['durations'], 'durations table result should not exist');
     });
-});
 
-test('table: distance table in Monaco with sources/destinations', function(assert) {
-    assert.plan(7);
-    var osrm = new OSRM(data_path);
-    var options = {
+    options = {
         coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
-        sources: [0],
-        destinations: [0,1]
+        annotations: ['duration']
     };
     osrm.table(options, function(err, table) {
         assert.ifError(err);
-        assert.ok(Array.isArray(table.durations), 'result must be an array');
-        var row_count = table.durations.length;
-        for (var i = 0; i < row_count; ++i) {
-            var column = table.durations[i];
-            var column_count = column.length;
-            assert.equal(options.destinations.length, column_count);
-            for (var j = 0; j < column_count; ++j) {
-                if (i == j) {
-                    // check that diagonal is zero
-                    assert.equal(0, column[j], 'diagonal must be zero');
-                } else {
-                    // everything else is non-zero
-                    assert.notEqual(0, column[j], 'other entries must be non-zero');
-                    // and finite (not nan, inf etc.)
-                    assert.ok(Number.isFinite(column[j]), 'distance is finite number');
-                }
-            }
-        }
-        assert.equal(options.sources.length, row_count);
+        assert.ok(table['durations'], 'durations table result should exist');
+        assert.notOk(table['distances'], 'distances table result should not exist');
     });
-});
 
-test('table: throws on invalid arguments', function(assert) {
-    assert.plan(14);
-    var osrm = new OSRM(data_path);
-    var options = {};
-    assert.throws(function() { osrm.table(options); },
-        /Two arguments required/);
-    options.coordinates = null;
-    assert.throws(function() { osrm.table(options, function() {}); },
-        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [three_test_coordinates[0]];
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /At least two coordinates must be provided/);
-    options.coordinates = three_test_coordinates[0];
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [three_test_coordinates[0][0], three_test_coordinates[0][1]];
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Coordinates must be an array of \(lon\/lat\) pairs/);
-
-    options.coordinates = two_test_coordinates;
-    options.sources = true;
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Sources must be an array of indices \(or undefined\)/);
-    options.sources = [0, 4];
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Source indices must be less than or equal to the number of coordinates/);
-    options.sources = [0.3, 1.1];
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Source must be an integer/);
-
-    options.destinations = true;
-    delete options.sources;
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Destinations must be an array of indices \(or undefined\)/);
-    options.destinations = [0, 4];
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Destination indices must be less than or equal to the number of coordinates/);
-    options.destinations = [0.3, 1.1];
-    assert.throws(function() { osrm.table(options, function(err, response) {}) },
-        /Destination must be an integer/);
-
-    // does not throw: the following two have been changed in OSRM v5
-    options.sources = [0, 1];
-    delete options.destinations;
-    assert.doesNotThrow(function() { osrm.table(options, function(err, response) {}) },
-        /Both sources and destinations need to be specified/);
-    options.destinations = [0, 1];
-    assert.doesNotThrow(function() { osrm.table(options, function(err, response) {}) },
-        /You can either specify sources and destinations, or coordinates/);
-
-    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, generate_hints: null}, function(err, route) {}) },
-        /generate_hints must be of type Boolean/);
-});
-
-test('table: throws on invalid arguments', function(assert) {
-    assert.plan(1);
-    var osrm = new OSRM(data_path);
-    assert.throws(function() { osrm.table(null, function() {}); },
-        /First arg must be an object/);
-});
-
-test('table: distance table in Monaco with hints', function(assert) {
-    assert.plan(5);
-    var osrm = new OSRM(data_path);
-    var options = {
-        coordinates: two_test_coordinates,
-        generate_hints: true  // true is default but be explicit here
+    options = {
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
+        annotations: ['duration', 'distance']
     };
     osrm.table(options, function(err, table) {
-        console.log(table);
         assert.ifError(err);
-
-        function assertHasHints(waypoint) {
-            assert.notStrictEqual(waypoint.hint, undefined);
-        }
-
-        table.sources.map(assertHasHints);
-        table.destinations.map(assertHasHints);
+        assert.ok(table['durations'], 'durations table result should exist');
+        assert.ok(table['distances'], 'distances table result should exist');
     });
-});
 
-test('table: distance table in Monaco without hints', function(assert) {
-    assert.plan(5);
-    var osrm = new OSRM(data_path);
-    var options = {
-        coordinates: two_test_coordinates,
-        generate_hints: false  // true is default
+    options = {
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]]
     };
     osrm.table(options, function(err, table) {
         assert.ifError(err);
+        assert.ok(table['durations'], 'durations table result should exist');
+        assert.notOk(table['distances'], 'distances table result should not exist');
+    });
+});
 
-        function assertHasNoHints(waypoint) {
-            assert.strictEqual(waypoint.hint, undefined);
-        }
+var tables = ['distances', 'durations'];
+
+tables.forEach(function(annotation) {
+    test('table: ' + annotation + ' table in Monaco', function(assert) {
+        assert.plan(11);
+        var osrm = new OSRM(data_path);
+        var options = {
+            coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
+            annotations: [annotation.slice(0,-1)]
+        };
+        osrm.table(options, function(err, table) {
+            assert.ifError(err);
+            assert.ok(Array.isArray(table[annotation]), 'result must be an array');
+            var row_count = table[annotation].length;
+            for (var i = 0; i < row_count; ++i) {
+                var column = table[annotation][i];
+                var column_count = column.length;
+                assert.equal(row_count, column_count);
+                for (var j = 0; j < column_count; ++j) {
+                    if (i == j) {
+                        // check that diagonal is zero
+                        assert.equal(0, column[j], 'diagonal must be zero');
+                    } else {
+                        // everything else is non-zero
+                        assert.notEqual(0, column[j], 'other entries must be non-zero');
+                        // and finite (not nan, inf etc.)
+                        assert.ok(Number.isFinite(column[j]), 'distance is finite number');
+                    }
+                }
+            }
+            assert.equal(options.coordinates.length, row_count);
+        });
+    });
 
-        table.sources.map(assertHasNoHints);
-        table.destinations.map(assertHasNoHints);
+    test('table: ' + annotation + ' table in Monaco with sources/destinations', function(assert) {
+        assert.plan(7);
+        var osrm = new OSRM(data_path);
+        var options = {
+            coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
+            sources: [0],
+            destinations: [0,1],
+            annotations: [annotation.slice(0,-1)]
+        };
+        osrm.table(options, function(err, table) {
+            assert.ifError(err);
+            assert.ok(Array.isArray(table[annotation]), 'result must be an array');
+            var row_count = table[annotation].length;
+            for (var i = 0; i < row_count; ++i) {
+                var column = table[annotation][i];
+                var column_count = column.length;
+                assert.equal(options.destinations.length, column_count);
+                for (var j = 0; j < column_count; ++j) {
+                    if (i == j) {
+                        // check that diagonal is zero
+                        assert.equal(0, column[j], 'diagonal must be zero');
+                    } else {
+                        // everything else is non-zero
+                        assert.notEqual(0, column[j], 'other entries must be non-zero');
+                        // and finite (not nan, inf etc.)
+                        assert.ok(Number.isFinite(column[j]), 'distance is finite number');
+                    }
+                }
+            }
+            assert.equal(options.sources.length, row_count);
+        });
     });
-});
 
-test('table: table in Monaco without motorways', function(assert) {
-    assert.plan(2);
-    var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
-    var options = {
-        coordinates: two_test_coordinates,
-        exclude: ['motorway']
-    };
-    osrm.table(options, function(err, response) {
-        assert.ifError(err);
-        assert.equal(response.durations.length, 2);
+    test('table: ' + annotation + ' throws on invalid arguments', function(assert) {
+        assert.plan(14);
+        var osrm = new OSRM(data_path);
+        var options = {annotations: [annotation.slice(0,-1)]};
+        assert.throws(function() { osrm.table(options); },
+            /Two arguments required/);
+        options.coordinates = null;
+        assert.throws(function() { osrm.table(options, function() {}); },
+            /Coordinates must be an array of \(lon\/lat\) pairs/);
+        options.coordinates = [three_test_coordinates[0]];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /At least two coordinates must be provided/);
+        options.coordinates = three_test_coordinates[0];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Coordinates must be an array of \(lon\/lat\) pairs/);
+        options.coordinates = [three_test_coordinates[0][0], three_test_coordinates[0][1]];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Coordinates must be an array of \(lon\/lat\) pairs/);
+
+        options.coordinates = two_test_coordinates;
+        options.sources = true;
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Sources must be an array of indices \(or undefined\)/);
+        options.sources = [0, 4];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Source indices must be less than or equal to the number of coordinates/);
+        options.sources = [0.3, 1.1];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Source must be an integer/);
+
+        options.destinations = true;
+        delete options.sources;
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Destinations must be an array of indices \(or undefined\)/);
+        options.destinations = [0, 4];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Destination indices must be less than or equal to the number of coordinates/);
+        options.destinations = [0.3, 1.1];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Destination must be an integer/);
+
+        // does not throw: the following two have been changed in OSRM v5
+        options.sources = [0, 1];
+        delete options.destinations;
+        assert.doesNotThrow(function() { osrm.table(options, function(err, response) {}) },
+            /Both sources and destinations need to be specified/);
+        options.destinations = [0, 1];
+        assert.doesNotThrow(function() { osrm.table(options, function(err, response) {}) },
+            /You can either specify sources and destinations, or coordinates/);
+
+        assert.throws(function() { osrm.route({coordinates: two_test_coordinates, generate_hints: null}, function(err, route) {}) },
+            /generate_hints must be of type Boolean/);
+    });
+
+    test('table: throws on invalid arguments', function(assert) {
+        assert.plan(1);
+        var osrm = new OSRM(data_path);
+        assert.throws(function() { osrm.table(null, function() {}); },
+            /First arg must be an object/);
+    });
+
+    test('table: ' + annotation + ' table in Monaco with hints', function(assert) {
+        assert.plan(5);
+        var osrm = new OSRM(data_path);
+        var options = {
+            coordinates: two_test_coordinates,
+            generate_hints: true,   // true is default but be explicit here
+            annotations: [annotation.slice(0,-1)]
+        };
+        osrm.table(options, function(err, table) {
+            assert.ifError(err);
+
+            function assertHasHints(waypoint) {
+                assert.notStrictEqual(waypoint.hint, undefined);
+            }
+
+            table.sources.map(assertHasHints);
+            table.destinations.map(assertHasHints);
+        });
+    });
+
+    test('table: ' + annotation + ' table in Monaco without hints', function(assert) {
+        assert.plan(5);
+        var osrm = new OSRM(data_path);
+        var options = {
+            coordinates: two_test_coordinates,
+            generate_hints: false,  // true is default
+            annotations: [annotation.slice(0,-1)]
+        };
+        osrm.table(options, function(err, table) {
+            assert.ifError(err);
+
+            function assertHasNoHints(waypoint) {
+                assert.strictEqual(waypoint.hint, undefined);
+            }
+
+            table.sources.map(assertHasNoHints);
+            table.destinations.map(assertHasNoHints);
+        });
+    });
+
+    test('table: ' + annotation + ' table in Monaco without motorways', function(assert) {
+        assert.plan(1);
+        var osrm = new OSRM({path: mld_data_path, algorithm: 'MLD'});
+        var options = {
+            coordinates: two_test_coordinates,
+            exclude: ['motorway'],
+            annotations: [annotation.slice(0,-1)]
+        };
+        osrm.table(options, function(err, response) {
+            assert.equal(response[annotation].length, 2);
+        });
     });
 });
 
diff --git a/third_party/cheap-ruler-cpp-2.5.4/.clang-format b/third_party/cheap-ruler-cpp-2.5.4/.clang-format
new file mode 100644
index 00000000000..ff0f39e73bb
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/.clang-format
@@ -0,0 +1,18 @@
+Standard: Cpp11
+IndentWidth: 4
+AccessModifierOffset: -4
+UseTab: Never
+BinPackParameters: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+AlwaysBreakTemplateDeclarations: true
+NamespaceIndentation: None
+PointerBindsToType: true
+SpacesInParentheses: false
+BreakBeforeBraces: Attach
+ColumnLimit: 100
+Cpp11BracedListStyle: false
+SpacesBeforeTrailingComments: 1
diff --git a/third_party/cheap-ruler-cpp-2.5.4/.gitignore b/third_party/cheap-ruler-cpp-2.5.4/.gitignore
new file mode 100644
index 00000000000..7117dfc1b4a
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/.gitignore
@@ -0,0 +1,2 @@
+build/
+mason_packages/
diff --git a/third_party/cheap-ruler-cpp-2.5.4/.travis.yml b/third_party/cheap-ruler-cpp-2.5.4/.travis.yml
new file mode 100644
index 00000000000..260d944a36d
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/.travis.yml
@@ -0,0 +1,25 @@
+language: generic
+
+matrix:
+  include:
+    - os: linux
+      env: CXX=g++-4.9
+      sudo: required
+      dist: trusty
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'g++-4.9', 'cmake', 'cmake-data' ]
+    - os: linux
+      env: CXX=g++-5
+      sudo: required
+      dist: trusty
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'g++-5', 'cmake', 'cmake-data' ]
+
+cache: apt
+
+script:
+ - cmake . && make && ./cheap_ruler
diff --git a/third_party/cheap-ruler-cpp-2.5.4/CMakeLists.txt b/third_party/cheap-ruler-cpp-2.5.4/CMakeLists.txt
new file mode 100644
index 00000000000..31bc80592da
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/CMakeLists.txt
@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
+project(cheap_ruler LANGUAGES CXX C)
+
+include(cmake/build.cmake)
+include(cmake/mason.cmake)
+
+set(CMAKE_OSX_DEPLOYMENT_TARGET 10.10)
+set(CMAKE_CONFIGURATION_TYPES Debug Release)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall -Wextra -Wpedantic -Wshadow")
+
+mason_use(geometry VERSION 0.9.2 HEADER_ONLY)
+mason_use(gtest VERSION 1.8.0)
+mason_use(variant VERSION 1.1.4 HEADER_ONLY)
+
+add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
+
+add_executable(cheap_ruler
+    ${PROJECT_SOURCE_DIR}/test/cheap_ruler.cpp
+)
+
+target_include_directories(cheap_ruler
+    PUBLIC ${PROJECT_SOURCE_DIR}/include
+)
+
+target_add_mason_package(cheap_ruler PRIVATE geometry)
+target_add_mason_package(cheap_ruler PRIVATE gtest)
+target_add_mason_package(cheap_ruler PRIVATE variant)
diff --git a/third_party/cheap-ruler-cpp-2.5.4/LICENSE b/third_party/cheap-ruler-cpp-2.5.4/LICENSE
new file mode 100644
index 00000000000..6f4f868bbc9
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2017, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
diff --git a/third_party/cheap-ruler-cpp-2.5.4/README.md b/third_party/cheap-ruler-cpp-2.5.4/README.md
new file mode 100644
index 00000000000..40ceab3e40d
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/README.md
@@ -0,0 +1,199 @@
+# cheap-ruler-cpp
+
+Port to C++ of [Cheap Ruler](https://github.com/mapbox/cheap-ruler), a collection of very fast approximations to common geodesic measurements.
+
+[![Build Status](https://travis-ci.org/mapbox/cheap-ruler-cpp.svg?branch=master)](https://travis-ci.org/mapbox/cheap-ruler-cpp)
+
+# Usage
+
+```cpp
+#include <mapbox/cheap_ruler.hpp>
+
+namespace cr = mapbox::cheap_ruler;
+```
+
+All `point`, `line_string`, `polygon`, and `box` references are [mapbox::geometry](https://github.com/mapbox/geometry.hpp) data structures.
+
+## Create a ruler object
+
+#### `CheapRuler(double latitude, Unit unit)`
+
+Creates a ruler object that will approximate measurements around the given latitude with an optional distance unit. Once created, the ruler object has access to the [methods](#methods) below.
+
+```cpp
+auto ruler = cr::CheapRuler(32.8351);
+auto milesRuler = cr::CheapRuler(32.8351, cr::CheapRuler::Miles);
+```
+
+Possible units:
+
+* `cheap_ruler::CheapRuler::Unit`
+* `cheap_ruler::CheapRuler::Kilometers`
+* `cheap_ruler::CheapRuler::Miles`
+* `cheap_ruler::CheapRuler::NauticalMiles`
+* `cheap_ruler::CheapRuler::Meters`
+* `cheap_ruler::CheapRuler::Yards`
+* `cheap_ruler::CheapRuler::Feet`
+* `cheap_ruler::CheapRuler::Inches`
+
+#### `CheapRuler::fromTile(uint32_t y, uint32_t z)`
+
+Creates a ruler object from tile coordinates (`y` and `z` integers). Convenient in tile-reduce scripts.
+
+```cpp
+auto ruler = cr::CheapRuler::fromTile(11041, 15);
+```
+
+## Methods
+
+#### `distance(point a, point b)`
+
+Given two points of the form [x = longitude, y = latitude], returns the distance (`double`).
+
+```cpp
+cr::point point_a{-96.9148, 32.8351};
+cr::point point_b{-96.9146, 32.8386};
+auto distance = ruler.distance(point_a, point_b);
+std::clog << distance; // 0.388595
+```
+
+#### `bearing(point a, point b)`
+
+Returns the bearing (`double`) between two points in angles.
+
+```cpp
+cr::point point_a{-96.9148, 32.8351};
+cr::point point_b{-96.9146, 32.8386};
+auto bearing = ruler.bearing(point_a, point_b);
+std::clog << bearing; // 2.76206
+```
+
+#### `destination(point origin, double distance, double bearing)`
+
+Returns a new point (`point`) given distance and bearing from the starting point.
+
+```cpp
+cr::point point_a{-96.9148, 32.8351};
+auto dest = ruler.destination(point_a, 1.0, -175);
+std::clog << dest.x << ", " << dest.y; // -96.9148, 32.8261
+```
+
+#### `offset(point origin, double dx, double dy)`
+
+Returns a new point (`point`) given easting and northing offsets from the starting point.
+
+```cpp
+cr::point point_a{-96.9148, 32.8351};
+auto os = ruler.offset(point_a, 10.0, -5.0);
+std::clog << os.x << ", " << os.y; // -96.808, 32.79
+```
+
+#### `lineDistance(const line_string& points)`
+
+Given a line (an array of points), returns the total line distance (`double`).
+
+```cpp
+cr::line_string line_a{{ -96.9, 32.8 }, { -96.8, 32.8 }, { -96.2, 32.3 }};
+auto line_distance = ruler.lineDistance(line_a);
+std::clog << line_distance; // 88.2962
+```
+
+#### `area(polygon poly)`
+
+Given a polygon (an array of rings, where each ring is an array of points), returns the area (`double`).
+
+```cpp
+cr::linear_ring ring{{ -96.9, 32.8 }, { -96.8, 32.8 }, { -96.2, 32.3 }, { -96.9, 32.8 }};
+auto area = ruler.area(cr::polygon{ ring });
+std::clog << area; //
+```
+
+#### `along(const line_string& line, double distance)`
+
+Returns the point (`point`) at a specified distance along the line.
+
+```cpp
+cr::linear_ring ring{{ -96.9, 32.8 }, { -96.8, 32.8 }, { -96.2, 32.3 }, { -96.9, 32.8 }};
+auto area = ruler.area(cr::polygon{ ring });
+std::clog << area; // 259.581
+```
+
+#### `pointOnLine(const line_string& line, point p)`
+
+Returns a tuple of the form `std::pair<point, unsigned>` where point is closest point on the line from the given point, index is the start index of the segment with the closest point, and t is a parameter from 0 to 1 that indicates where the closest point is on that segment.
+
+```cpp
+cr::line_string line{{ -96.9, 32.8 }, { -96.8, 32.8 }, { -96.2, 32.3 }};
+cr::point point{-96.9, 32.79};
+auto pol = ruler.pointOnLine(line, point);
+auto point = std::get<0>(pol);
+std::clog << point.x << ", " << point.y; // -96.9, 32.8 (point)
+std::clog << std::get<1>(pol); // 0 (index)
+std::clog << std::get<2>(pol); // 0. (t)
+```
+
+#### `lineSlice(point start, point stop, const line_string& line)`
+
+Returns a part of the given line (`line_string`) between the start and the stop points (or their closest points on the line).
+
+```cpp
+cr::line_string line{{ -96.9, 32.8 }, { -96.8, 32.8 }, { -96.2, 32.3 }};
+cr::point start_point{-96.9, 32.8};
+cr::point stop_point{-96.8, 32.8};
+auto slice = ruler.lineSlice(start_point, stop_point, line);
+std::clog << slice[0].x << ", " << slice[0].y; // -96.9, 32.8
+std::clog << slice[1].x << ", " << slice[1].y; // -96.8, 32.8
+```
+
+#### `lineSliceAlong(double start, double stop, const line_string& line)`
+
+Returns a part of the given line (`line_string`) between the start and the stop points indicated by distance along the line.
+
+```cpp
+cr::line_string line{{ -96.9, 32.8 }, { -96.8, 32.8 }, { -96.2, 32.3 }};
+auto slice = ruler.lineSliceAlong(0.1, 1.2, line);
+```
+
+#### `bufferPoint(point p, double buffer)`
+
+Given a point, returns a bounding box object ([w, s, e, n]) created from the given point buffered by a given distance.
+
+```cpp
+cr::point point{-96.9, 32.8};
+auto box = ruler.bufferPoint(point, 0.1);
+```
+
+#### `bufferBBox(box bbox, double buffer)`
+
+Given a bounding box, returns the box buffered by a given distance.
+
+```cpp
+cr::box bbox({ 30, 38 }, { 40, 39 });
+auto bbox2 = ruler.bufferBBox(bbox, 1);
+```
+
+#### `insideBBox(point p, box bbox)`
+
+Returns true (`bool`) if the given point is inside in the given bounding box, otherwise false.
+
+```cpp
+cr::box bbox({ 30, 38 }, { 40, 39 });
+auto inside = ruler.insideBBox({ 35, 38.5 }, bbox);
+std::clog << inside; // true
+```
+
+# Develop
+
+```shell
+# create targets
+cmake .
+
+# build
+make
+
+# test
+./cheap_ruler
+
+# or just do it all in one!
+cmake . && make && ./cheap_ruler
+```
diff --git a/third_party/cheap-ruler-cpp-2.5.4/cmake/build.cmake b/third_party/cheap-ruler-cpp-2.5.4/cmake/build.cmake
new file mode 100644
index 00000000000..79168336d6d
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/cmake/build.cmake
@@ -0,0 +1,11 @@
+# Generate source groups so the files are properly sorted in IDEs like Xcode.
+function(create_source_groups target)
+    get_target_property(sources ${target} SOURCES)
+    foreach(file ${sources})
+        get_filename_component(file "${file}" ABSOLUTE)
+        string(REGEX REPLACE "^${CMAKE_SOURCE_DIR}/" "" group "${file}")
+        get_filename_component(group "${group}" DIRECTORY)
+        string(REPLACE "/" "\\" group "${group}")
+        source_group("${group}" FILES "${file}")
+    endforeach()
+endfunction()
diff --git a/third_party/cheap-ruler-cpp-2.5.4/cmake/mason.cmake b/third_party/cheap-ruler-cpp-2.5.4/cmake/mason.cmake
new file mode 100644
index 00000000000..bc31feeb5f2
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/cmake/mason.cmake
@@ -0,0 +1,235 @@
+# Mason CMake
+
+include(CMakeParseArguments)
+
+function(mason_detect_platform)
+    # Determine platform
+    if(NOT MASON_PLATFORM)
+        # we call uname -s manually here since
+        # CMAKE_HOST_SYSTEM_NAME will not be defined before the project() call
+        execute_process(
+            COMMAND uname -s
+            OUTPUT_VARIABLE UNAME
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+        if (UNAME STREQUAL "Darwin")
+            set(MASON_PLATFORM "osx" PARENT_SCOPE)
+        else()
+            set(MASON_PLATFORM "linux" PARENT_SCOPE)
+        endif()
+    endif()
+
+    # Determine platform version string
+    if(NOT MASON_PLATFORM_VERSION)
+        # Android Studio only passes ANDROID_ABI, but we need to adjust that to the Mason
+        if(MASON_PLATFORM STREQUAL "android" AND NOT MASON_PLATFORM_VERSION)
+            if (ANDROID_ABI STREQUAL "armeabi")
+                set(MASON_PLATFORM_VERSION "arm-v5-9" PARENT_SCOPE)
+            elseif (ANDROID_ABI STREQUAL "armeabi-v7a")
+                set(MASON_PLATFORM_VERSION "arm-v7-9" PARENT_SCOPE)
+            elseif (ANDROID_ABI STREQUAL "arm64-v8a")
+                set(MASON_PLATFORM_VERSION "arm-v8-21" PARENT_SCOPE)
+            elseif (ANDROID_ABI STREQUAL "x86")
+                set(MASON_PLATFORM_VERSION "x86-9" PARENT_SCOPE)
+            elseif (ANDROID_ABI STREQUAL "x86_64")
+                set(MASON_PLATFORM_VERSION "x86-64-21" PARENT_SCOPE)
+            elseif (ANDROID_ABI STREQUAL "mips")
+                set(MASON_PLATFORM_VERSION "mips-9" PARENT_SCOPE)
+            elseif (ANDROID_ABI STREQUAL "mips64")
+                set(MASON_PLATFORM_VERSION "mips-64-9" PARENT_SCOPE)
+            else()
+                message(FATAL_ERROR "Unknown ANDROID_ABI '${ANDROID_ABI}'.")
+            endif()
+        elseif(MASON_PLATFORM STREQUAL "ios")
+            set(MASON_PLATFORM_VERSION "8.0" PARENT_SCOPE)
+        else()
+            execute_process(
+                COMMAND uname -m
+                OUTPUT_VARIABLE MASON_PLATFORM_VERSION
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+            set(MASON_PLATFORM_VERSION "${MASON_PLATFORM_VERSION}" PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
+
+function(mason_use _PACKAGE)
+    if(NOT _PACKAGE)
+        message(FATAL_ERROR "[Mason] No package name given")
+    endif()
+
+    cmake_parse_arguments("" "HEADER_ONLY" "VERSION" "" ${ARGN})
+
+    if(_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "[Mason] mason_use() called with unrecognized arguments: ${_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT _VERSION)
+        message(FATAL_ERROR "[Mason] Specifying a version is required")
+    endif()
+
+    if(MASON_PACKAGE_${_PACKAGE}_INVOCATION STREQUAL "${MASON_INVOCATION}")
+        # Check that the previous invocation of mason_use didn't select another version of this package
+        if(NOT MASON_PACKAGE_${_PACKAGE}_VERSION STREQUAL ${_VERSION})
+            message(FATAL_ERROR "[Mason] Already using ${_PACKAGE} ${MASON_PACKAGE_${_PACKAGE}_VERSION}. Cannot select version ${_VERSION}.")
+        endif()
+    else()
+        if(_HEADER_ONLY)
+            set(_PLATFORM_ID "headers")
+        else()
+            set(_PLATFORM_ID "${MASON_PLATFORM}-${MASON_PLATFORM_VERSION}")
+        endif()
+
+        set(_SLUG "${_PLATFORM_ID}/${_PACKAGE}/${_VERSION}")
+        set(_INSTALL_PATH "${MASON_PACKAGE_DIR}/${_SLUG}")
+        file(RELATIVE_PATH _INSTALL_PATH_RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${_INSTALL_PATH}")
+
+        if(NOT EXISTS "${_INSTALL_PATH}")
+            set(_CACHE_PATH "${MASON_PACKAGE_DIR}/.binaries/${_SLUG}.tar.gz")
+            if (NOT EXISTS "${_CACHE_PATH}")
+                # Download the package
+                set(_URL "${MASON_REPOSITORY}/${_SLUG}.tar.gz")
+                message("[Mason] Downloading package ${_URL}...")
+
+                set(_FAILED)
+                set(_ERROR)
+                # Note: some CMake versions are compiled without SSL support
+                get_filename_component(_CACHE_DIR "${_CACHE_PATH}" DIRECTORY)
+                file(MAKE_DIRECTORY "${_CACHE_DIR}")
+                execute_process(
+                    COMMAND curl --retry 3 -s -f -S -L "${_URL}" -o "${_CACHE_PATH}.tmp"
+                    RESULT_VARIABLE _FAILED
+                    ERROR_VARIABLE _ERROR)
+                if(_FAILED)
+                    message(FATAL_ERROR "[Mason] Failed to download ${_URL}: ${_ERROR}")
+                else()
+                    # We downloaded to a temporary file to prevent half-finished downloads
+                    file(RENAME "${_CACHE_PATH}.tmp" "${_CACHE_PATH}")
+                endif()
+            endif()
+
+            # Unpack the package
+            message("[Mason] Unpacking package to ${_INSTALL_PATH_RELATIVE}...")
+            file(MAKE_DIRECTORY "${_INSTALL_PATH}")
+            execute_process(
+                COMMAND ${CMAKE_COMMAND} -E tar xzf "${_CACHE_PATH}"
+                WORKING_DIRECTORY "${_INSTALL_PATH}")
+        endif()
+
+        # Error out if there is no config file.
+        if(NOT EXISTS "${_INSTALL_PATH}/mason.ini")
+            message(FATAL_ERROR "[Mason] Could not find mason.ini for package ${_PACKAGE} ${_VERSION}")
+        endif()
+
+        set(MASON_PACKAGE_${_PACKAGE}_PREFIX "${_INSTALL_PATH}" CACHE STRING "${_PACKAGE} ${_INSTALL_PATH}" FORCE)
+        mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_PREFIX)
+
+        # Load the configuration from the ini file
+        file(STRINGS "${_INSTALL_PATH}/mason.ini" _CONFIG_FILE)
+        foreach(_LINE IN LISTS _CONFIG_FILE)
+            string(REGEX MATCH "^([a-z_]+) *= *" _KEY "${_LINE}")
+            if (_KEY)
+                string(LENGTH "${_KEY}" _KEY_LENGTH)
+                string(SUBSTRING "${_LINE}" ${_KEY_LENGTH} -1 _VALUE)
+                string(REGEX REPLACE ";.*$" "" _VALUE "${_VALUE}") # Trim trailing commas
+                string(REPLACE "{prefix}" "${_INSTALL_PATH}" _VALUE "${_VALUE}")
+                string(STRIP "${_VALUE}" _VALUE)
+                string(REPLACE "=" "" _KEY "${_KEY}")
+                string(STRIP "${_KEY}" _KEY)
+                string(TOUPPER "${_KEY}" _KEY)
+                if(_KEY STREQUAL "INCLUDE_DIRS" OR _KEY STREQUAL "STATIC_LIBS" )
+                    separate_arguments(_VALUE)
+                endif()
+                set(MASON_PACKAGE_${_PACKAGE}_${_KEY} "${_VALUE}" CACHE STRING "${_PACKAGE} ${_KEY}" FORCE)
+                mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_${_KEY})
+            endif()
+        endforeach()
+
+        # Compare version in the package to catch errors early on
+        if(NOT _VERSION STREQUAL MASON_PACKAGE_${_PACKAGE}_VERSION)
+            message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has version '${MASON_PACKAGE_${_PACKAGE}_VERSION}', but required '${_VERSION}'")
+        endif()
+
+        if(NOT _PACKAGE STREQUAL MASON_PACKAGE_${_PACKAGE}_NAME)
+            message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has name '${MASON_PACKAGE_${_PACKAGE}_NAME}', but required '${_NAME}'")
+        endif()
+
+        if(NOT _HEADER_ONLY)
+            if(NOT MASON_PLATFORM STREQUAL MASON_PACKAGE_${_PACKAGE}_PLATFORM)
+                message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has platform '${MASON_PACKAGE_${_PACKAGE}_PLATFORM}', but required '${MASON_PLATFORM}'")
+            endif()
+
+            if(NOT MASON_PLATFORM_VERSION STREQUAL MASON_PACKAGE_${_PACKAGE}_PLATFORM_VERSION)
+                message(FATAL_ERROR "[Mason] Package at ${_INSTALL_PATH_RELATIVE} has platform version '${MASON_PACKAGE_${_PACKAGE}_PLATFORM_VERSION}', but required '${MASON_PLATFORM_VERSION}'")
+            endif()
+        endif()
+
+        # Concatenate the static libs and libraries
+        set(_LIBRARIES)
+        list(APPEND _LIBRARIES ${MASON_PACKAGE_${_PACKAGE}_STATIC_LIBS} ${MASON_PACKAGE_${_PACKAGE}_LDFLAGS})
+        set(MASON_PACKAGE_${_PACKAGE}_LIBRARIES "${_LIBRARIES}" CACHE STRING "${_PACKAGE} _LIBRARIES" FORCE)
+        mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_LIBRARIES)
+
+        if(NOT _HEADER_ONLY)
+            string(REGEX MATCHALL "(^| +)-L *([^ ]+)" MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LDFLAGS}")
+            string(REGEX REPLACE "(^| +)-L *" "\\1" MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}")
+            set(MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS "${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}" CACHE STRING "${_PACKAGE} ${MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS}" FORCE)
+            mark_as_advanced(MASON_PACKAGE_${_PACKAGE}_LIBRARY_DIRS)
+        endif()
+
+        # Store invocation ID to prevent different versions of the same package in one invocation
+        set(MASON_PACKAGE_${_PACKAGE}_INVOCATION "${MASON_INVOCATION}" CACHE INTERNAL "${_PACKAGE} invocation ID" FORCE)
+    endif()
+endfunction()
+
+macro(target_add_mason_package _TARGET _VISIBILITY _PACKAGE)
+    if (NOT MASON_PACKAGE_${_PACKAGE}_INVOCATION)
+        message(FATAL_ERROR "[Mason] Package ${_PACKAGE} has not been initialized yet")
+    endif()
+
+    target_include_directories(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_INCLUDE_DIRS}")
+    target_compile_definitions(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_DEFINITIONS}")
+    target_compile_options(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_OPTIONS}")
+    target_link_libraries(${_TARGET} ${_VISIBILITY} "${MASON_PACKAGE_${_PACKAGE}_LIBRARIES}")
+endmacro()
+
+# Setup
+
+string(RANDOM LENGTH 16 MASON_INVOCATION)
+
+# Read environment variables if CMake is run in command mode
+if (CMAKE_ARGC)
+    set(MASON_PLATFORM "$ENV{MASON_PLATFORM}")
+    set(MASON_PLATFORM_VERSION "$ENV{MASON_PLATFORM_VERSION}")
+    set(MASON_PACKAGE_DIR "$ENV{MASON_PACKAGE_DIR}")
+    set(MASON_REPOSITORY "$ENV{MASON_REPOSITORY}")
+endif()
+
+# Directory where Mason packages are located; typically ends with mason_packages
+if (NOT MASON_PACKAGE_DIR)
+    set(MASON_PACKAGE_DIR "${CMAKE_SOURCE_DIR}/mason_packages")
+endif()
+
+# URL prefix of where packages are located.
+if (NOT MASON_REPOSITORY)
+    set(MASON_REPOSITORY "https://mason-binaries.s3.amazonaws.com")
+endif()
+
+mason_detect_platform()
+
+# Execute commands if CMake is run in command mode
+if (CMAKE_ARGC)
+    # Collect remaining arguments for passing to mason_use
+    set(_MASON_ARGS)
+    foreach(I RANGE 4 ${CMAKE_ARGC})
+        list(APPEND _MASON_ARGS "${CMAKE_ARGV${I}}")
+    endforeach()
+
+    # Install the package
+    mason_use(${_MASON_ARGS})
+
+    # Optionally print variables
+    if(DEFINED MASON_PACKAGE_${CMAKE_ARGV4}_${CMAKE_ARGV3})
+        # CMake can't write to stdout with message()
+        execute_process(COMMAND ${CMAKE_COMMAND} -E echo "${MASON_PACKAGE_${CMAKE_ARGV4}_${CMAKE_ARGV3}}")
+    endif()
+endif()
diff --git a/third_party/cheap-ruler-cpp-2.5.4/include/mapbox/cheap_ruler.hpp b/third_party/cheap-ruler-cpp-2.5.4/include/mapbox/cheap_ruler.hpp
new file mode 100644
index 00000000000..d5ae7428b28
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/include/mapbox/cheap_ruler.hpp
@@ -0,0 +1,354 @@
+#pragma once
+
+#include <mapbox/geometry.hpp>
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <tuple>
+#include <utility>
+
+namespace mapbox {
+namespace cheap_ruler {
+
+using box               = geometry::box<double>;
+using line_string       = geometry::line_string<double>;
+using linear_ring       = geometry::linear_ring<double>;
+using multi_line_string = geometry::multi_line_string<double>;
+using point             = geometry::point<double>;
+using polygon           = geometry::polygon<double>;
+
+class CheapRuler {
+public:
+    enum Unit {
+        Kilometers,
+        Miles,
+        NauticalMiles,
+        Meters,
+        Metres = Meters,
+        Yards,
+        Feet,
+        Inches
+    };
+
+    //
+    // A collection of very fast approximations to common geodesic measurements. Useful
+    // for performance-sensitive code that measures things on a city scale. Point coordinates
+    // are in the [x = longitude, y = latitude] form.
+    //
+    explicit CheapRuler(double latitude, Unit unit = Kilometers) {
+        double m = 0.;
+
+        switch (unit) {
+        case Kilometers:
+            m = 1.;
+            break;
+        case Miles:
+            m = 1000. / 1609.344;
+            break;
+        case NauticalMiles:
+            m = 1000. / 1852.;
+            break;
+        case Meters:
+            m = 1000.;
+            break;
+        case Yards:
+            m = 1000. / 0.9144;
+            break;
+        case Feet:
+            m = 1000. / 0.3048;
+            break;
+        case Inches:
+            m = 1000. / 0.0254;
+            break;
+        }
+
+        auto cos = std::cos(latitude * M_PI / 180.);
+        auto cos2 = 2. * cos * cos - 1.;
+        auto cos3 = 2. * cos * cos2 - cos;
+        auto cos4 = 2. * cos * cos3 - cos2;
+        auto cos5 = 2. * cos * cos4 - cos3;
+
+        // multipliers for converting longitude and latitude
+        // degrees into distance (http://1.usa.gov/1Wb1bv7)
+        kx = m * (111.41513 * cos - 0.09455 * cos3 + 0.00012 * cos5);
+        ky = m * (111.13209 - 0.56605 * cos2 + 0.0012 * cos4);
+    }
+
+    static CheapRuler fromTile(uint32_t y, uint32_t z) {
+        double n = M_PI * (1. - 2. * (y + 0.5) / std::pow(2., z));
+        double latitude = std::atan(0.5 * (std::exp(n) - std::exp(-n))) * 180. / M_PI;
+
+        return CheapRuler(latitude);
+    }
+
+    //
+    // Given two points of the form [x = longitude, y = latitude], returns the distance.
+    //
+    double distance(point a, point b) {
+        auto dx = (a.x - b.x) * kx;
+        auto dy = (a.y - b.y) * ky;
+
+        return std::sqrt(dx * dx + dy * dy);
+    }
+
+    //
+    // Returns the bearing between two points in angles.
+    //
+    double bearing(point a, point b) {
+        auto dx = (b.x - a.x) * kx;
+        auto dy = (b.y - a.y) * ky;
+
+        if (!dx && !dy) {
+            return 0.;
+        }
+
+        auto value = std::atan2(dx, dy) * 180. / M_PI;
+
+        if (value > 180.) {
+            value -= 360.;
+        }
+
+        return value;
+    }
+
+    //
+    // Returns a new point given distance and bearing from the starting point.
+    //
+    point destination(point origin, double dist, double bearing_) {
+        auto a = (90. - bearing_) * M_PI / 180.;
+
+        return offset(origin, std::cos(a) * dist, std::sin(a) * dist);
+    }
+
+    //
+    // Returns a new point given easting and northing offsets from the starting point.
+    //
+    point offset(point origin, double dx, double dy) {
+        return point(origin.x + dx / kx, origin.y + dy / ky);
+    }
+
+    //
+    // Given a line (an array of points), returns the total line distance.
+    //
+    double lineDistance(const line_string& points) {
+        double total = 0.;
+
+        for (unsigned i = 0; i < points.size() - 1; ++i) {
+            total += distance(points[i], points[i + 1]);
+        }
+
+        return total;
+    }
+
+    //
+    // Given a polygon (an array of rings, where each ring is an array of points),
+    // returns the area.
+    //
+    double area(polygon poly) {
+        double sum = 0.;
+
+        for (unsigned i = 0; i < poly.size(); ++i) {
+            auto& ring = poly[i];
+
+            for (unsigned j = 0, len = ring.size(), k = len - 1; j < len; k = j++) {
+                sum += (ring[j].x - ring[k].x) * (ring[j].y + ring[k].y) * (i ? -1. : 1.);
+            }
+        }
+
+        return (std::abs(sum) / 2.) * kx * ky;
+    }
+
+    //
+    // Returns the point at a specified distance along the line.
+    //
+    point along(const line_string& line, double dist) {
+        double sum = 0.;
+
+        if (dist <= 0.) {
+            return line[0];
+        }
+
+        for (unsigned i = 0; i < line.size() - 1; ++i) {
+            auto p0 = line[i];
+            auto p1 = line[i + 1];
+            auto d = distance(p0, p1);
+
+            sum += d;
+
+            if (sum > dist) {
+                return interpolate(p0, p1, (dist - (sum - d)) / d);
+            }
+        }
+
+        return line[line.size() - 1];
+    }
+
+    //
+    // Returns a tuple of the form <point, index, t> where point is closest point on the line
+    // from the given point, index is the start index of the segment with the closest point,
+    // and t is a parameter from 0 to 1 that indicates where the closest point is on that segment.
+    //
+    std::tuple<point, unsigned, double> pointOnLine(const line_string& line, point p) {
+        double minDist = std::numeric_limits<double>::infinity();
+        double minX = 0., minY = 0., minI = 0., minT = 0.;
+
+        for (unsigned i = 0; i < line.size() - 1; ++i) {
+            auto t = 0.;
+            auto x = line[i].x;
+            auto y = line[i].y;
+            auto dx = (line[i + 1].x - x) * kx;
+            auto dy = (line[i + 1].y - y) * ky;
+
+            if (dx != 0. || dy != 0.) {
+                t = ((p.x - x) * kx * dx + (p.y - y) * ky * dy) / (dx * dx + dy * dy);
+
+                if (t > 1) {
+                    x = line[i + 1].x;
+                    y = line[i + 1].y;
+
+                } else if (t > 0) {
+                    x += (dx / kx) * t;
+                    y += (dy / ky) * t;
+                }
+            }
+
+            dx = (p.x - x) * kx;
+            dy = (p.y - y) * ky;
+
+            auto sqDist = dx * dx + dy * dy;
+
+            if (sqDist < minDist) {
+                minDist = sqDist;
+                minX = x;
+                minY = y;
+                minI = i;
+                minT = t;
+            }
+        }
+
+        return std::make_tuple(
+                point(minX, minY), minI, ::fmax(0., ::fmin(1., minT)));
+    }
+
+    //
+    // Returns a part of the given line between the start and the stop points (or their closest
+    // points on the line).
+    //
+    line_string lineSlice(point start, point stop, const line_string& line) {
+        auto getPoint = [](auto tuple) { return std::get<0>(tuple); };
+        auto getIndex = [](auto tuple) { return std::get<1>(tuple); };
+        auto getT     = [](auto tuple) { return std::get<2>(tuple); };
+
+        auto p1 = pointOnLine(line, start);
+        auto p2 = pointOnLine(line, stop);
+
+        if (getIndex(p1) > getIndex(p2) || (getIndex(p1) == getIndex(p2) && getT(p1) > getT(p2))) {
+            auto tmp = p1;
+            p1 = p2;
+            p2 = tmp;
+        }
+
+        line_string slice = { getPoint(p1) };
+
+        auto l = getIndex(p1) + 1;
+        auto r = getIndex(p2);
+
+        if (line[l] != slice[0] && l <= r) {
+            slice.push_back(line[l]);
+        }
+
+        for (unsigned i = l + 1; i <= r; ++i) {
+            slice.push_back(line[i]);
+        }
+
+        if (line[r] != getPoint(p2)) {
+            slice.push_back(getPoint(p2));
+        }
+
+        return slice;
+    };
+
+    //
+    // Returns a part of the given line between the start and the stop points
+    // indicated by distance along the line.
+    //
+    line_string lineSliceAlong(double start, double stop, const line_string& line) {
+        double sum = 0.;
+        line_string slice;
+
+        for (unsigned i = 0; i < line.size() - 1; ++i) {
+            auto p0 = line[i];
+            auto p1 = line[i + 1];
+            auto d = distance(p0, p1);
+
+            sum += d;
+
+            if (sum > start && slice.size() == 0) {
+                slice.push_back(interpolate(p0, p1, (start - (sum - d)) / d));
+            }
+
+            if (sum >= stop) {
+                slice.push_back(interpolate(p0, p1, (stop - (sum - d)) / d));
+                return slice;
+            }
+
+            if (sum > start) {
+                slice.push_back(p1);
+            }
+        }
+
+        return slice;
+    };
+
+    //
+    // Given a point, returns a bounding box object ([w, s, e, n])
+    // created from the given point buffered by a given distance.
+    //
+    box bufferPoint(point p, double buffer) {
+        auto v = buffer / ky;
+        auto h = buffer / kx;
+
+        return box(
+            point(p.x - h, p.y - v),
+            point(p.x + h, p.y + v)
+        );
+    }
+
+    //
+    // Given a bounding box, returns the box buffered by a given distance.
+    //
+    box bufferBBox(box bbox, double buffer) {
+        auto v = buffer / ky;
+        auto h = buffer / kx;
+
+        return box(
+            point(bbox.min.x - h, bbox.min.y - v),
+            point(bbox.max.x + h, bbox.max.y + v)
+        );
+    }
+
+    //
+    // Returns true if the given point is inside in the given bounding box, otherwise false.
+    //
+    bool insideBBox(point p, box bbox) {
+        return p.x >= bbox.min.x &&
+               p.x <= bbox.max.x &&
+               p.y >= bbox.min.y &&
+               p.y <= bbox.max.y;
+    }
+
+    static point interpolate(point a, point b, double t) {
+        double dx = b.x - a.x;
+        double dy = b.y - a.y;
+
+        return point(a.x + dx * t, a.y + dy * t);
+    }
+
+private:
+    double ky;
+    double kx;
+};
+
+} // namespace cheap_ruler
+} // namespace mapbox
diff --git a/third_party/cheap-ruler-cpp-2.5.4/test/cheap_ruler.cpp b/third_party/cheap-ruler-cpp-2.5.4/test/cheap_ruler.cpp
new file mode 100644
index 00000000000..0ac73c81fb0
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/test/cheap_ruler.cpp
@@ -0,0 +1,200 @@
+#include <mapbox/cheap_ruler.hpp>
+#include <gtest/gtest.h>
+
+#include "fixtures/lines.hpp"
+#include "fixtures/turf.hpp"
+
+namespace cr = mapbox::cheap_ruler;
+
+class CheapRulerTest : public ::testing::Test {
+protected:
+    cr::CheapRuler ruler = cr::CheapRuler(32.8351);
+    cr::CheapRuler milesRuler = cr::CheapRuler(32.8351, cr::CheapRuler::Miles);
+};
+
+void assertErr(double expected, double actual, double maxError) {
+    // Add a negligible fraction to make sure we
+    // don't divide by zero.
+    double error = std::abs((actual - expected) /
+            (expected == 0. ? expected + 0.000001 : expected));
+
+    if (error > maxError) {
+        FAIL() << "expected is " << expected << " but got " << actual;
+    }
+}
+
+TEST_F(CheapRulerTest, distance) {
+    for (unsigned i = 0; i < points.size() - 1; ++i) {
+        auto expected = turf_distance[i];
+        auto actual = ruler.distance(points[i], points[i + 1]);
+
+        assertErr(expected, actual, .003);
+    }
+}
+
+TEST_F(CheapRulerTest, distanceInMiles) {
+    auto d = ruler.distance({ 30.5, 32.8351 }, { 30.51, 32.8451 });
+    auto d2 = milesRuler.distance({ 30.5, 32.8351 }, { 30.51, 32.8451 });
+
+    assertErr(d / d2, 1.609344, 1e-12);
+}
+
+TEST_F(CheapRulerTest, bearing) {
+    for (unsigned i = 0; i < points.size() - 1; ++i) {
+        auto expected = turf_bearing[i];
+        auto actual = ruler.bearing(points[i], points[i + 1]);
+
+        assertErr(expected, actual, .005);
+    }
+}
+
+TEST_F(CheapRulerTest, destination) {
+    for (unsigned i = 0; i < points.size(); ++i) {
+        auto bearing = (i % 360) - 180.;
+        auto expected = turf_destination[i];
+        auto actual = ruler.destination(points[i], 1.0, bearing);
+
+        assertErr(expected.x, actual.x, 1e-6); // longitude
+        assertErr(expected.y, actual.y, 1e-6); // latitude
+    }
+}
+
+TEST_F(CheapRulerTest, lineDistance) {
+    for (unsigned i = 0; i < lines.size(); ++i) {
+        auto expected = turf_lineDistance[i];
+        auto actual = ruler.lineDistance(lines[i]);
+
+        assertErr(expected, actual, 0.003);
+    }
+}
+
+TEST_F(CheapRulerTest, area) {
+    for (unsigned i = 0, j = 0; i < lines.size(); ++i) {
+        if (lines[i].size() < 3) {
+            continue;
+        }
+
+        cr::linear_ring ring;
+        for (auto point : lines[i]) {
+            ring.push_back(point);
+        }
+        ring.push_back(lines[i][0]);
+
+        auto expected = turf_area[j++];
+        auto actual = ruler.area(cr::polygon{ ring });
+
+        assertErr(expected, actual, 0.003);
+    }
+}
+
+TEST_F(CheapRulerTest, along) {
+    for (unsigned i = 0; i < lines.size(); ++i) {
+        auto expected = turf_along[i];
+        auto actual = ruler.along(lines[i], turf_along_dist[i]);
+
+        assertErr(expected.x, actual.x, 1e-6); // along longitude
+        assertErr(expected.y, actual.y, 1e-6); // along latitude
+    }
+}
+
+TEST_F(CheapRulerTest, alongWithDist) {
+    ASSERT_EQ(ruler.along(lines[0], -5), lines[0][0]);
+}
+
+TEST_F(CheapRulerTest, alongWithDistGreaterThanLength) {
+    ASSERT_EQ(ruler.along(lines[0], 1000), lines[0][lines[0].size() - 1]);
+}
+
+TEST_F(CheapRulerTest, pointOnLine) {
+    // not Turf comparison because pointOnLine is bugged https://github.com/Turfjs/turf/issues/344
+    cr::line_string line = {{ -77.031669, 38.878605 }, { -77.029609, 38.881946 }};
+    auto result = ruler.pointOnLine(line, { -77.034076, 38.882017 });
+
+    ASSERT_EQ(std::get<0>(result), cr::point(-77.03052697027461, 38.880457194811896)); // point
+    ASSERT_EQ(std::get<1>(result), 0u); // index
+    ASSERT_EQ(std::get<2>(result), 0.5543833618360235); // t
+
+    ASSERT_EQ(std::get<2>(ruler.pointOnLine(line, { -80., 38. })), 0.) << "t is not less than 0";
+    ASSERT_EQ(std::get<2>(ruler.pointOnLine(line, { -75., 38. })), 1.) << "t is not bigger than 1";
+}
+
+TEST_F(CheapRulerTest, lineSlice) {
+    for (unsigned i = 0; i < lines.size(); ++i) {
+        auto line = lines[i];
+        auto dist = ruler.lineDistance(line);
+        auto start = ruler.along(line, dist * 0.3);
+        auto stop = ruler.along(line, dist * 0.7);
+        auto expected = turf_lineSlice[i];
+        auto actual = ruler.lineDistance(ruler.lineSlice(start, stop, line));
+
+        assertErr(expected, actual, 1e-5);
+    }
+}
+
+TEST_F(CheapRulerTest, lineSliceAlong) {
+    for (unsigned i = 0; i < lines.size(); ++i) {
+        if (i == 46) {
+            // skip due to Turf bug https://github.com/Turfjs/turf/issues/351
+            continue;
+        };
+
+        auto line = lines[i];
+        auto dist = ruler.lineDistance(line);
+        auto expected = turf_lineSlice[i];
+        auto actual = ruler.lineDistance(ruler.lineSliceAlong(dist * 0.3, dist * 0.7, line));
+
+        assertErr(expected, actual, 1e-5);
+    }
+}
+
+TEST_F(CheapRulerTest, lineSliceReverse) {
+    auto line = lines[0];
+    auto dist = ruler.lineDistance(line);
+    auto start = ruler.along(line, dist * 0.7);
+    auto stop = ruler.along(line, dist * 0.3);
+    auto actual = ruler.lineDistance(ruler.lineSlice(start, stop, line));
+
+    ASSERT_EQ(actual, 0.018676802802910702);
+}
+
+TEST_F(CheapRulerTest, bufferPoint) {
+    for (unsigned i = 0; i < points.size(); ++i) {
+        auto expected = turf_bufferPoint[i];
+        auto actual = milesRuler.bufferPoint(points[i], 0.1);
+
+        assertErr(expected.min.x, actual.min.x, 2e-7);
+        assertErr(expected.min.x, actual.min.x, 2e-7);
+        assertErr(expected.max.y, actual.max.y, 2e-7);
+        assertErr(expected.max.y, actual.max.y, 2e-7);
+    }
+}
+
+TEST_F(CheapRulerTest, bufferBBox) {
+    cr::box bbox({ 30, 38 }, { 40, 39 });
+    cr::box bbox2 = ruler.bufferBBox(bbox, 1);
+
+    ASSERT_EQ(bbox2, cr::box({ 29.989319515875376, 37.99098271225711 }, { 40.01068048412462, 39.00901728774289 }));
+}
+
+TEST_F(CheapRulerTest, insideBBox) {
+    cr::box bbox({ 30, 38 }, { 40, 39 });
+
+    ASSERT_TRUE(ruler.insideBBox({ 35, 38.5 }, bbox));
+    ASSERT_FALSE(ruler.insideBBox({ 45, 45 }, bbox));
+}
+
+TEST_F(CheapRulerTest, fromTile) {
+    auto ruler1 = cr::CheapRuler(50.5);
+    auto ruler2 = cr::CheapRuler::fromTile(11041, 15);
+
+    cr::point p1(30.5, 50.5);
+    cr::point p2(30.51, 50.51);
+
+    assertErr(ruler1.distance(p1, p2), ruler2.distance(p1, p2), 2e-5);
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+
+    return RUN_ALL_TESTS();
+}
diff --git a/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/lines.hpp b/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/lines.hpp
new file mode 100644
index 00000000000..d2ec79d3435
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/lines.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <mapbox/cheap_ruler.hpp>
+
+namespace cr = mapbox::cheap_ruler;
+
+static const cr::multi_line_string lines = {{{ -96.920341, 32.838261 }, { -96.920421, 32.838295 }, { -96.920421, 32.838295 }, { -96.920536, 32.838297 }, { -96.920684, 32.838293 }, { -96.920818, 32.838342 }}, {{ -96.920349, 32.838306 }, { -96.920421, 32.838295 }}, {{ -96.919874, 32.837479 }, { -96.920097, 32.837684 }, { -96.92018, 32.837844 }, { -96.92029, 32.838216 }, { -96.920341, 32.838261 }}, {{ -96.915781, 32.834689 }, { -96.915735, 32.834529 }, { -96.91573, 32.834443 }, { -96.915733, 32.834286 }, { -96.915853, 32.8337 }}, {{ -96.915092, 32.836889 }, { -96.915915, 32.836977 }}, {{ -96.914617, 32.83752 }, { -96.914507, 32.838106 }, { -96.914319, 32.839063 }}, {{ -96.915671, 32.833443 }, { -96.915427, 32.833817 }, { -96.91532, 32.833963 }, { -96.915247, 32.834072 }, { -96.915062, 32.834252 }, { -96.914775, 32.834518 }}, {{ -96.9104, 32.837119 }, { -96.910567, 32.837069 }, { -96.9111, 32.836941 }}, {{ -96.91441, 32.836582 }, { -96.914225, 32.836544 }, { -96.914158, 32.836499 }, { -96.914107, 32.836449 }, { -96.914075, 32.836393 }, { -96.914059, 32.836292 }, { -96.914091, 32.836073 }, { -96.914649, 32.834919 }, { -96.914837, 32.834601 }, { -96.914858, 32.834583 }, { -96.914912, 32.834563 }, { -96.914968, 32.834561 }, { -96.91503, 32.83457 }, { -96.915081, 32.834592 }, { -96.915116, 32.834628 }, { -96.915134, 32.834671 }, { -96.91514, 32.834718 }, { -96.915124, 32.834793 }, { -96.914931, 32.835336 }, { -96.914888, 32.835509 }, { -96.91481, 32.835911 }}, {{ -96.914155, 32.836758 }, { -96.913391, 32.836697 }, { -96.912991, 32.836643 }, { -96.912847, 32.836589 }, { -96.912761, 32.836508 }, { -96.912573, 32.836433 }}, {{ -96.917377, 32.837281 }, { -96.917589, 32.837317 }, { -96.918117, 32.837339 }}, {{ -96.920815, 32.836594 }, { -96.919732, 32.836643 }, { -96.918975, 32.836702 }, { -96.918077, 32.836729 }, { -96.916661, 32.83672 }, { -96.916358, 32.836774 }}, {{ -96.911543, 32.836925 }, { -96.911806, 32.837006 }, { -96.911994, 32.837028 }, { -96.912326, 32.837114 }, { -96.912552, 32.837202 }, { -96.912656, 32.83729 }}, {{ -96.914657, 32.836659 }, { -96.914518, 32.837522 }, { -96.914472, 32.837673 }, { -96.914383, 32.837772 }, { -96.914284, 32.837858 }, { -96.914153, 32.837905 }, { -96.914024, 32.837912 }, { -96.913925, 32.837885 }, { -96.913804, 32.837828 }, { -96.913678, 32.837729 }, { -96.913391, 32.837479 }, { -96.913278, 32.837328 }, { -96.913252, 32.837238 }, { -96.913262, 32.837148 }, { -96.913305, 32.837078 }, { -96.91337, 32.837024 }, { -96.91348, 32.837004 }, { -96.914483, 32.83688 }}, {{ -96.915915, 32.836977 }, { -96.916183, 32.837004 }, { -96.916425, 32.837042 }, { -96.916862, 32.837164 }}, {{ -96.915183, 32.840102 }, { -96.915151, 32.839929 }, { -96.915113, 32.839539 }, { -96.915008, 32.838973 }, { -96.914949, 32.83873 }, { -96.914909, 32.838491 }, { -96.914834, 32.838234 }}, {{ -96.914728, 32.842674 }, { -96.914772, 32.84257 }, { -96.914872, 32.842277 }, { -96.914974, 32.841939 }, { -96.915014, 32.841646 }, { -96.915065, 32.84138 }, { -96.915113, 32.84099 }, { -96.915175, 32.840321 }, { -96.915193, 32.839827 }, { -96.915204, 32.839345 }, { -96.91525, 32.839045 }, { -96.915325, 32.838759 }, { -96.915483, 32.838464 }, { -96.915658, 32.838236 }, { -96.915907, 32.837943 }, { -96.91621, 32.837709 }, { -96.91636, 32.837612 }, { -96.916588, 32.837481 }, { -96.916948, 32.837324 }, { -96.91731, 32.837188 }, { -96.918026, 32.837098 }, { -96.918847, 32.83706 }, { -96.919391, 32.83704 }, { -96.919847, 32.83701 }, { -96.920174, 32.836961 }}, {{ -96.914603, 32.839688 }, { -96.914335, 32.841087 }, { -96.914099, 32.841896 }, { -96.913823, 32.842577 }, { -96.91377, 32.842674 }}, {{ -96.915915, 32.836977 }, { -96.916105, 32.837042 }, { -96.916183, 32.837116 }, { -96.916218, 32.837164 }, { -96.916232, 32.83722 }, { -96.916223, 32.837308 }, { -96.916202, 32.837355 }, { -96.916006, 32.837556 }, { -96.915714, 32.837779 }, { -96.915588, 32.83784 }, { -96.915419, 32.837871 }, { -96.915293, 32.837867 }, { -96.91514, 32.837828 }, { -96.915062, 32.837774 }, { -96.915014, 32.837734 }, { -96.914925, 32.837614 }, { -96.914888, 32.837515 }, { -96.914831, 32.837297 }}, {{ -96.917743, 32.833443 }, { -96.917766, 32.836553 }}, {{ -96.912399, 32.842674 }, { -96.911487, 32.841373 }, { -96.9104, 32.841399 }}, {{ -96.91072, 32.84264 }, { -96.910717, 32.842674 }}, {{ -96.911584, 32.833443 }, { -96.911581, 32.833684 }, { -96.911559, 32.835271 }, { -96.911554, 32.83642 }}, {{ -96.920403, 32.833443 }, { -96.920397, 32.833894 }}, {{ -96.9104, 32.833662 }, { -96.911581, 32.833684 }}, {{ -96.914775, 32.834518 }, { -96.914512, 32.835038 }, { -96.914327, 32.835437 }, { -96.914016, 32.836136 }, { -96.913973, 32.83621 }, { -96.913906, 32.83628 }, { -96.913769, 32.836359 }, { -96.913675, 32.836384 }, { -96.913203, 32.836445 }}, {{ -96.9104, 32.837231 }, { -96.910695, 32.837202 }, { -96.911025, 32.837182 }, { -96.911355, 32.837168 }, { -96.911948, 32.837168 }, { -96.912391, 32.837222 }, { -96.912656, 32.83729 }, { -96.913072, 32.83752 }}, {{ -96.916189, 32.83818 }, { -96.918117, 32.837339 }}, {{ -96.918165, 32.84179 }, { -96.917329, 32.840988 }, { -96.91702, 32.840704 }, { -96.916811, 32.840587 }, { -96.916661, 32.840519 }, { -96.916368, 32.840454 }, { -96.916164, 32.840438 }, { -96.915263, 32.840458 }}, {{ -96.914137, 32.840553 }, { -96.914316, 32.840555 }}, {{ -96.91415, 32.840452 }, { -96.914054, 32.841182 }, { -96.913976, 32.841572 }, { -96.913842, 32.842049 }, { -96.913691, 32.842414 }, { -96.913569, 32.842674 }}, {{ -96.914919, 32.842674 }, { -96.91492, 32.842671 }, { -96.9151, 32.842171 }, { -96.915244, 32.84152 }, { -96.915322, 32.840979 }, { -96.915376, 32.840569 }, { -96.915384, 32.840454 }}, {{ -96.915474, 32.833443 }, { -96.915379, 32.833664 }, { -96.915314, 32.833772 }, { -96.915261, 32.833849 }, { -96.915081, 32.834083 }, { -96.914775, 32.834518 }}, {{ -96.913072, 32.83752 }, { -96.913195, 32.837608 }, { -96.913675, 32.838002 }, { -96.913694, 32.838011 }, { -96.91396, 32.838241 }, { -96.914054, 32.838345 }, { -96.914161, 32.838507 }, { -96.914255, 32.838714 }, { -96.914292, 32.83889 }, { -96.914319, 32.839063 }, { -96.914182, 32.840098 }, { -96.91415, 32.840452 }}, {{ -96.917406, 32.836557 }, { -96.91588, 32.836517 }, { -96.915778, 32.836501 }, { -96.915727, 32.836481 }, { -96.91569, 32.836458 }, { -96.915644, 32.836422 }, { -96.915609, 32.836382 }, { -96.915588, 32.836348 }, { -96.915572, 32.836305 }, { -96.915564, 32.836235 }, { -96.915564, 32.836154 }, { -96.915668, 32.835469 }, { -96.915754, 32.834827 }, { -96.915781, 32.834689 }, { -96.915835, 32.834556 }, { -96.916052, 32.834074 }, { -96.916283, 32.833443 }}, {{ -96.915384, 32.840454 }, { -96.915408, 32.839794 }, { -96.915411, 32.839345 }, { -96.915459, 32.839068 }, { -96.91554, 32.838845 }, { -96.915636, 32.838687 }, { -96.915765, 32.838529 }, { -96.915945, 32.838358 }, { -96.916189, 32.83818 }}, {{ -96.919421, 32.837159 }, { -96.919557, 32.837216 }, { -96.919697, 32.837288 }, { -96.919812, 32.8374 }, { -96.919874, 32.837479 }, { -96.920172, 32.838358 }, { -96.920295, 32.838845 }, { -96.920333, 32.839068 }, { -96.920327, 32.839422 }, { -96.920223, 32.839746 }, { -96.920072, 32.840046 }, { -96.919898, 32.840276 }, { -96.919812, 32.840355 }, { -96.919426, 32.84067 }, { -96.918012, 32.84172 }, { -96.91753, 32.84207 }, { -96.917374, 32.842196 }, { -96.916727, 32.842674 }}, {{ -96.916981, 32.842674 }, { -96.917079, 32.842602 }, { -96.917487, 32.842291 }, { -96.918114, 32.841826 }, { -96.919984, 32.840454 }, { -96.920236, 32.840233 }, { -96.920429, 32.839965 }, { -96.920512, 32.839816 }, { -96.92059, 32.839557 }, { -96.920612, 32.839271 }, { -96.920604, 32.839181 }, { -96.920574, 32.839043 }, { -96.920416, 32.83857 }, { -96.920365, 32.83839 }, { -96.920341, 32.838261 }, { -96.9203, 32.838119 }, { -96.920282, 32.837943 }, { -96.920274, 32.83775 }, { -96.920295, 32.837603 }, { -96.920319, 32.837536 }, { -96.920397, 32.837407 }, { -96.920515, 32.837288 }, { -96.920601, 32.837227 }, { -96.920727, 32.83717 }}, {{ -96.91441, 32.836582 }, { -96.914188, 32.836571 }, { -96.913203, 32.836445 }}, {{ -96.914324, 32.840454 }, { -96.91415, 32.840452 }}, {{ -96.921387, 32.836595 }, { -96.920815, 32.836594 }, { -96.917766, 32.836553 }, { -96.917406, 32.836557 }, { -96.915851, 32.836621 }, { -96.915459, 32.836621 }, { -96.915129, 32.836607 }}, {{ -96.918117, 32.837339 }, { -96.918324, 32.837252 }, { -96.918586, 32.837186 }, { -96.918844, 32.837161 }, { -96.919421, 32.837159 }, { -96.920727, 32.83717 }, { -96.921387, 32.83717 }}, {{ -96.913203, 32.836445 }, { -96.913142, 32.836438 }, { -96.912999, 32.836438 }, { -96.912774, 32.836427 }, { -96.912573, 32.836433 }, { -96.911554, 32.83642 }, { -96.9104, 32.836416 }}, {{ -96.915253, 32.840564 }, { -96.915376, 32.840569 }, { -96.915816, 32.840562 }, { -96.916197, 32.840567 }, { -96.916478, 32.840598 }, { -96.916623, 32.840641 }, { -96.916757, 32.840702 }, { -96.916913, 32.840794 }, { -96.917326, 32.841157 }, { -96.917452, 32.841272 }, { -96.917956, 32.841761 }, { -96.918061, 32.841867 }}, {{ -96.9145, 32.842674 }, { -96.914547, 32.842534 }, { -96.914708, 32.841971 }, { -96.914802, 32.841473 }, { -96.914858, 32.841078 }, { -96.914882, 32.840742 }, { -96.914907, 32.840224 }, { -96.914915, 32.839706 }, { -96.914885, 32.839084 }, { -96.914826, 32.83811 }, { -96.914831, 32.837297 }}, {{ -96.914987, 32.836886 }, { -96.915092, 32.836889 }}, {{ -96.914526, 32.836763 }, { -96.914155, 32.836758 }, { -96.9104, 32.836758 }}, {{ -96.921387, 32.836813 }, { -96.918825, 32.836796 }, { -96.916358, 32.836774 }, { -96.915003, 32.836767 }}, {{ -96.914831, 32.837297 }, { -96.914872, 32.836663 }, { -96.915033, 32.835872 }, { -96.91514, 32.83546 }, { -96.915226, 32.835212 }, { -96.915853, 32.8337 }, { -96.91595, 32.833443 }}, {{ -96.915092, 32.836889 }, { -96.916398, 32.836891 }, { -96.919547, 32.836963 }, { -96.921322, 32.836952 }, { -96.921387, 32.836952 }}, {{ -96.9104, 32.837008 }, { -96.910671, 32.836977 }, { -96.9111, 32.836941 }, { -96.911543, 32.836925 }, { -96.912637, 32.836898 }, { -96.913501, 32.836886 }, { -96.914528, 32.83688 }}, {{ -96.91577, 32.833443 }, { -96.915671, 32.833693 }, { -96.915344, 32.834518 }, { -96.91481, 32.835911 }, { -96.914754, 32.836127 }, { -96.914657, 32.836659 }, { -96.914617, 32.83752 }, { -96.914595, 32.838561 }, { -96.914603, 32.839688 }, { -96.914587, 32.840693 }, { -96.914512, 32.841211 }, { -96.914421, 32.841666 }, { -96.914284, 32.842196 }, { -96.914097, 32.842674 }}, {{ -96.914316, 32.840555 }, { -96.915253, 32.840564 }}, {{ -96.916862, 32.837164 }, { -96.917377, 32.837281 }}, {{ -96.915129, 32.836607 }, { -96.91441, 32.836582 }}, {{ -96.915263, 32.840458 }, { -96.914324, 32.840454 }}, {{ -96.914528, 32.83688 }, { -96.914987, 32.836886 }}, {{ -96.915003, 32.836767 }, { -96.914526, 32.836763 }}};
+static const cr::line_string points = {{ -96.920341, 32.838261 }, { -96.920421, 32.838295 }, { -96.920421, 32.838295 }, { -96.920536, 32.838297 }, { -96.920684, 32.838293 }, { -96.920818, 32.838342 }, { -96.920349, 32.838306 }, { -96.920421, 32.838295 }, { -96.919874, 32.837479 }, { -96.920097, 32.837684 }, { -96.92018, 32.837844 }, { -96.92029, 32.838216 }, { -96.920341, 32.838261 }, { -96.915781, 32.834689 }, { -96.915735, 32.834529 }, { -96.91573, 32.834443 }, { -96.915733, 32.834286 }, { -96.915853, 32.8337 }, { -96.915092, 32.836889 }, { -96.915915, 32.836977 }, { -96.914617, 32.83752 }, { -96.914507, 32.838106 }, { -96.914319, 32.839063 }, { -96.915671, 32.833443 }, { -96.915427, 32.833817 }, { -96.91532, 32.833963 }, { -96.915247, 32.834072 }, { -96.915062, 32.834252 }, { -96.914775, 32.834518 }, { -96.9104, 32.837119 }, { -96.910567, 32.837069 }, { -96.9111, 32.836941 }, { -96.91441, 32.836582 }, { -96.914225, 32.836544 }, { -96.914158, 32.836499 }, { -96.914107, 32.836449 }, { -96.914075, 32.836393 }, { -96.914059, 32.836292 }, { -96.914091, 32.836073 }, { -96.914649, 32.834919 }, { -96.914837, 32.834601 }, { -96.914858, 32.834583 }, { -96.914912, 32.834563 }, { -96.914968, 32.834561 }, { -96.91503, 32.83457 }, { -96.915081, 32.834592 }, { -96.915116, 32.834628 }, { -96.915134, 32.834671 }, { -96.91514, 32.834718 }, { -96.915124, 32.834793 }, { -96.914931, 32.835336 }, { -96.914888, 32.835509 }, { -96.91481, 32.835911 }, { -96.914155, 32.836758 }, { -96.913391, 32.836697 }, { -96.912991, 32.836643 }, { -96.912847, 32.836589 }, { -96.912761, 32.836508 }, { -96.912573, 32.836433 }, { -96.917377, 32.837281 }, { -96.917589, 32.837317 }, { -96.918117, 32.837339 }, { -96.920815, 32.836594 }, { -96.919732, 32.836643 }, { -96.918975, 32.836702 }, { -96.918077, 32.836729 }, { -96.916661, 32.83672 }, { -96.916358, 32.836774 }, { -96.911543, 32.836925 }, { -96.911806, 32.837006 }, { -96.911994, 32.837028 }, { -96.912326, 32.837114 }, { -96.912552, 32.837202 }, { -96.912656, 32.83729 }, { -96.914657, 32.836659 }, { -96.914518, 32.837522 }, { -96.914472, 32.837673 }, { -96.914383, 32.837772 }, { -96.914284, 32.837858 }, { -96.914153, 32.837905 }, { -96.914024, 32.837912 }, { -96.913925, 32.837885 }, { -96.913804, 32.837828 }, { -96.913678, 32.837729 }, { -96.913391, 32.837479 }, { -96.913278, 32.837328 }, { -96.913252, 32.837238 }, { -96.913262, 32.837148 }, { -96.913305, 32.837078 }, { -96.91337, 32.837024 }, { -96.91348, 32.837004 }, { -96.914483, 32.83688 }, { -96.915915, 32.836977 }, { -96.916183, 32.837004 }, { -96.916425, 32.837042 }, { -96.916862, 32.837164 }, { -96.915183, 32.840102 }, { -96.915151, 32.839929 }, { -96.915113, 32.839539 }, { -96.915008, 32.838973 }, { -96.914949, 32.83873 }, { -96.914909, 32.838491 }, { -96.914834, 32.838234 }, { -96.914728, 32.842674 }, { -96.914772, 32.84257 }, { -96.914872, 32.842277 }, { -96.914974, 32.841939 }, { -96.915014, 32.841646 }, { -96.915065, 32.84138 }, { -96.915113, 32.84099 }, { -96.915175, 32.840321 }, { -96.915193, 32.839827 }, { -96.915204, 32.839345 }, { -96.91525, 32.839045 }, { -96.915325, 32.838759 }, { -96.915483, 32.838464 }, { -96.915658, 32.838236 }, { -96.915907, 32.837943 }, { -96.91621, 32.837709 }, { -96.91636, 32.837612 }, { -96.916588, 32.837481 }, { -96.916948, 32.837324 }, { -96.91731, 32.837188 }, { -96.918026, 32.837098 }, { -96.918847, 32.83706 }, { -96.919391, 32.83704 }, { -96.919847, 32.83701 }, { -96.920174, 32.836961 }, { -96.914603, 32.839688 }, { -96.914335, 32.841087 }, { -96.914099, 32.841896 }, { -96.913823, 32.842577 }, { -96.91377, 32.842674 }, { -96.915915, 32.836977 }, { -96.916105, 32.837042 }, { -96.916183, 32.837116 }, { -96.916218, 32.837164 }, { -96.916232, 32.83722 }, { -96.916223, 32.837308 }, { -96.916202, 32.837355 }, { -96.916006, 32.837556 }, { -96.915714, 32.837779 }, { -96.915588, 32.83784 }, { -96.915419, 32.837871 }, { -96.915293, 32.837867 }, { -96.91514, 32.837828 }, { -96.915062, 32.837774 }, { -96.915014, 32.837734 }, { -96.914925, 32.837614 }, { -96.914888, 32.837515 }, { -96.914831, 32.837297 }, { -96.917743, 32.833443 }, { -96.917766, 32.836553 }, { -96.912399, 32.842674 }, { -96.911487, 32.841373 }, { -96.9104, 32.841399 }, { -96.91072, 32.84264 }, { -96.910717, 32.842674 }, { -96.911584, 32.833443 }, { -96.911581, 32.833684 }, { -96.911559, 32.835271 }, { -96.911554, 32.83642 }, { -96.920403, 32.833443 }, { -96.920397, 32.833894 }, { -96.9104, 32.833662 }, { -96.911581, 32.833684 }, { -96.914775, 32.834518 }, { -96.914512, 32.835038 }, { -96.914327, 32.835437 }, { -96.914016, 32.836136 }, { -96.913973, 32.83621 }, { -96.913906, 32.83628 }, { -96.913769, 32.836359 }, { -96.913675, 32.836384 }, { -96.913203, 32.836445 }, { -96.9104, 32.837231 }, { -96.910695, 32.837202 }, { -96.911025, 32.837182 }, { -96.911355, 32.837168 }, { -96.911948, 32.837168 }, { -96.912391, 32.837222 }, { -96.912656, 32.83729 }, { -96.913072, 32.83752 }, { -96.916189, 32.83818 }, { -96.918117, 32.837339 }, { -96.918165, 32.84179 }, { -96.917329, 32.840988 }, { -96.91702, 32.840704 }, { -96.916811, 32.840587 }, { -96.916661, 32.840519 }, { -96.916368, 32.840454 }, { -96.916164, 32.840438 }, { -96.915263, 32.840458 }, { -96.914137, 32.840553 }, { -96.914316, 32.840555 }, { -96.91415, 32.840452 }, { -96.914054, 32.841182 }, { -96.913976, 32.841572 }, { -96.913842, 32.842049 }, { -96.913691, 32.842414 }, { -96.913569, 32.842674 }, { -96.914919, 32.842674 }, { -96.91492, 32.842671 }, { -96.9151, 32.842171 }, { -96.915244, 32.84152 }, { -96.915322, 32.840979 }, { -96.915376, 32.840569 }, { -96.915384, 32.840454 }, { -96.915474, 32.833443 }, { -96.915379, 32.833664 }, { -96.915314, 32.833772 }, { -96.915261, 32.833849 }, { -96.915081, 32.834083 }, { -96.914775, 32.834518 }, { -96.913072, 32.83752 }, { -96.913195, 32.837608 }, { -96.913675, 32.838002 }, { -96.913694, 32.838011 }, { -96.91396, 32.838241 }, { -96.914054, 32.838345 }, { -96.914161, 32.838507 }, { -96.914255, 32.838714 }, { -96.914292, 32.83889 }, { -96.914319, 32.839063 }, { -96.914182, 32.840098 }, { -96.91415, 32.840452 }, { -96.917406, 32.836557 }, { -96.91588, 32.836517 }, { -96.915778, 32.836501 }, { -96.915727, 32.836481 }, { -96.91569, 32.836458 }, { -96.915644, 32.836422 }, { -96.915609, 32.836382 }, { -96.915588, 32.836348 }, { -96.915572, 32.836305 }, { -96.915564, 32.836235 }, { -96.915564, 32.836154 }, { -96.915668, 32.835469 }, { -96.915754, 32.834827 }, { -96.915781, 32.834689 }, { -96.915835, 32.834556 }, { -96.916052, 32.834074 }, { -96.916283, 32.833443 }, { -96.915384, 32.840454 }, { -96.915408, 32.839794 }, { -96.915411, 32.839345 }, { -96.915459, 32.839068 }, { -96.91554, 32.838845 }, { -96.915636, 32.838687 }, { -96.915765, 32.838529 }, { -96.915945, 32.838358 }, { -96.916189, 32.83818 }, { -96.919421, 32.837159 }, { -96.919557, 32.837216 }, { -96.919697, 32.837288 }, { -96.919812, 32.8374 }, { -96.919874, 32.837479 }, { -96.920172, 32.838358 }, { -96.920295, 32.838845 }, { -96.920333, 32.839068 }, { -96.920327, 32.839422 }, { -96.920223, 32.839746 }, { -96.920072, 32.840046 }, { -96.919898, 32.840276 }, { -96.919812, 32.840355 }, { -96.919426, 32.84067 }, { -96.918012, 32.84172 }, { -96.91753, 32.84207 }, { -96.917374, 32.842196 }, { -96.916727, 32.842674 }, { -96.916981, 32.842674 }, { -96.917079, 32.842602 }, { -96.917487, 32.842291 }, { -96.918114, 32.841826 }, { -96.919984, 32.840454 }, { -96.920236, 32.840233 }, { -96.920429, 32.839965 }, { -96.920512, 32.839816 }, { -96.92059, 32.839557 }, { -96.920612, 32.839271 }, { -96.920604, 32.839181 }, { -96.920574, 32.839043 }, { -96.920416, 32.83857 }, { -96.920365, 32.83839 }, { -96.920341, 32.838261 }, { -96.9203, 32.838119 }, { -96.920282, 32.837943 }, { -96.920274, 32.83775 }, { -96.920295, 32.837603 }, { -96.920319, 32.837536 }, { -96.920397, 32.837407 }, { -96.920515, 32.837288 }, { -96.920601, 32.837227 }, { -96.920727, 32.83717 }, { -96.91441, 32.836582 }, { -96.914188, 32.836571 }, { -96.913203, 32.836445 }, { -96.914324, 32.840454 }, { -96.91415, 32.840452 }, { -96.921387, 32.836595 }, { -96.920815, 32.836594 }, { -96.917766, 32.836553 }, { -96.917406, 32.836557 }, { -96.915851, 32.836621 }, { -96.915459, 32.836621 }, { -96.915129, 32.836607 }, { -96.918117, 32.837339 }, { -96.918324, 32.837252 }, { -96.918586, 32.837186 }, { -96.918844, 32.837161 }, { -96.919421, 32.837159 }, { -96.920727, 32.83717 }, { -96.921387, 32.83717 }, { -96.913203, 32.836445 }, { -96.913142, 32.836438 }, { -96.912999, 32.836438 }, { -96.912774, 32.836427 }, { -96.912573, 32.836433 }, { -96.911554, 32.83642 }, { -96.9104, 32.836416 }, { -96.915253, 32.840564 }, { -96.915376, 32.840569 }, { -96.915816, 32.840562 }, { -96.916197, 32.840567 }, { -96.916478, 32.840598 }, { -96.916623, 32.840641 }, { -96.916757, 32.840702 }, { -96.916913, 32.840794 }, { -96.917326, 32.841157 }, { -96.917452, 32.841272 }, { -96.917956, 32.841761 }, { -96.918061, 32.841867 }, { -96.9145, 32.842674 }, { -96.914547, 32.842534 }, { -96.914708, 32.841971 }, { -96.914802, 32.841473 }, { -96.914858, 32.841078 }, { -96.914882, 32.840742 }, { -96.914907, 32.840224 }, { -96.914915, 32.839706 }, { -96.914885, 32.839084 }, { -96.914826, 32.83811 }, { -96.914831, 32.837297 }, { -96.914987, 32.836886 }, { -96.915092, 32.836889 }, { -96.914526, 32.836763 }, { -96.914155, 32.836758 }, { -96.9104, 32.836758 }, { -96.921387, 32.836813 }, { -96.918825, 32.836796 }, { -96.916358, 32.836774 }, { -96.915003, 32.836767 }, { -96.914831, 32.837297 }, { -96.914872, 32.836663 }, { -96.915033, 32.835872 }, { -96.91514, 32.83546 }, { -96.915226, 32.835212 }, { -96.915853, 32.8337 }, { -96.91595, 32.833443 }, { -96.915092, 32.836889 }, { -96.916398, 32.836891 }, { -96.919547, 32.836963 }, { -96.921322, 32.836952 }, { -96.921387, 32.836952 }, { -96.9104, 32.837008 }, { -96.910671, 32.836977 }, { -96.9111, 32.836941 }, { -96.911543, 32.836925 }, { -96.912637, 32.836898 }, { -96.913501, 32.836886 }, { -96.914528, 32.83688 }, { -96.91577, 32.833443 }, { -96.915671, 32.833693 }, { -96.915344, 32.834518 }, { -96.91481, 32.835911 }, { -96.914754, 32.836127 }, { -96.914657, 32.836659 }, { -96.914617, 32.83752 }, { -96.914595, 32.838561 }, { -96.914603, 32.839688 }, { -96.914587, 32.840693 }, { -96.914512, 32.841211 }, { -96.914421, 32.841666 }, { -96.914284, 32.842196 }, { -96.914097, 32.842674 }, { -96.914316, 32.840555 }, { -96.915253, 32.840564 }, { -96.916862, 32.837164 }, { -96.917377, 32.837281 }, { -96.915129, 32.836607 }, { -96.91441, 32.836582 }, { -96.915263, 32.840458 }, { -96.914324, 32.840454 }, { -96.914528, 32.83688 }, { -96.914987, 32.836886 }, { -96.915003, 32.836767 }, { -96.914526, 32.836763 }};
diff --git a/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/turf.hpp b/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/turf.hpp
new file mode 100644
index 00000000000..42301aa97bc
--- /dev/null
+++ b/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/turf.hpp
@@ -0,0 +1,1894 @@
+#pragma once
+
+#include <mapbox/cheap_ruler.hpp>
+
+// Pre-computed test expectations with turf.js
+
+namespace cr = mapbox::cheap_ruler;
+
+static const std::vector<double> turf_distance = {
+    0.008378522721530966,
+    0,
+    0.010749717813535198,
+    0.013838610971284946,
+    0.013657697587927904,
+    0.044013281621164545,
+    0.0068391514197623125,
+    0.10416972567189697,
+    0.030891354635076577,
+    0.019413765237647276,
+    0.04263542169525046,
+    0.0069116261879168155,
+    0.582645708508002,
+    0.018308680637617696,
+    0.009577172911626559,
+    0.017465334500943574,
+    0.06613851306063838,
+    0.3617719377192654,
+    0.07753561751121403,
+    0.13551122988625394,
+    0.06598639029222791,
+    0.10788718733352708,
+    0.637754036319657,
+    0.04744046409407494,
+    0.019071666981656257,
+    0.013911884201543205,
+    0.026453803385838824,
+    0.03993584290435518,
+    0.5008820538480422,
+    0.016568611251168885,
+    0.05180738530903197,
+    0.3119106296673429,
+    0.017798808015935193,
+    0.008016350616268752,
+    0.007324494221885543,
+    0.006909617037766451,
+    0.01133329359318173,
+    0.024542232038179984,
+    0.13854858779974746,
+    0.039494712699750543,
+    0.002803669222998928,
+    0.005515366276063487,
+    0.005238469974132169,
+    0.005880339789619507,
+    0.005357898801346142,
+    0.0051705154162532425,
+    0.005070109623060704,
+    0.0052577908286051914,
+    0.00847519939173927,
+    0.06303372152921366,
+    0.019657925611790725,
+    0.045304719345077606,
+    0.11235257808731806,
+    0.07172313743043487,
+    0.03786245739823775,
+    0.014737426160375995,
+    0.012073619242440572,
+    0.01944992465839253,
+    0.4587699541978461,
+    0.02021344170822001,
+    0.04940583279333197,
+    0.26541509069849073,
+    0.10136117015958783,
+    0.071051047335519,
+    0.0839785094261126,
+    0.13233952591634118,
+    0.028947596386964588,
+    0.450310288271311,
+    0.02617846959013443,
+    0.01773953006642692,
+    0.03246883345774803,
+    0.023279127631702524,
+    0.013794142444291755,
+    0.19974484175602678,
+    0.0968663637124452,
+    0.017337159580454113,
+    0.013800054342251185,
+    0.013308139694942028,
+    0.01331222080564702,
+    0.012080965868250661,
+    0.009727373321527968,
+    0.012964274265275947,
+    0.016122067768646026,
+    0.03863515912787102,
+    0.019839914076975624,
+    0.010301365066689631,
+    0.010054214744799303,
+    0.008762005427975264,
+    0.008542780137735616,
+    0.010518226790403411,
+    0.09474686301917724,
+    0.1342649575551186,
+    0.02522592703114516,
+    0.023008194493208647,
+    0.04303616022369959,
+    0.36251220899321573,
+    0.019473754396392998,
+    0.043524753809585405,
+    0.06371623663872246,
+    0.02758552742766217,
+    0.026845476675765343,
+    0.029432835806681268,
+    0.4939597997561797,
+    0.012276958817933555,
+    0.03390371747191658,
+    0.03878525490806829,
+    0.03280401819558517,
+    0.02996855089043349,
+    0.043610944953640665,
+    0.07463799480713804,
+    0.054973280670314324,
+    0.05362263439641399,
+    0.03364472557328668,
+    0.03257474948646934,
+    0.035982127999637514,
+    0.03017661243030025,
+    0.04004558186048798,
+    0.03846182853667192,
+    0.017689723726582205,
+    0.02581380073796066,
+    0.03790654917278124,
+    0.0370593711860446,
+    0.06765988226898403,
+    0.07684458549068582,
+    0.05088930944950997,
+    0.04274689073720004,
+    0.031042698873467,
+    0.6025557457581485,
+    0.15761319510469404,
+    0.09264826777038944,
+    0.08001841776554604,
+    0.011871825072563895,
+    0.664627433433829,
+    0.01917232375926572,
+    0.01099493090349843,
+    0.006261363451393286,
+    0.0063648042581234765,
+    0.009824297643237445,
+    0.005584056437412894,
+    0.028902860335050025,
+    0.03687758065157599,
+    0.013590391879516907,
+    0.016166117999544854,
+    0.011783888353457304,
+    0.01494235041421174,
+    0.009445375968215059,
+    0.0063181221302946585,
+    0.015727070675584043,
+    0.011541912177440836,
+    0.024826353234049702,
+    0.5077727699239808,
+    0.345931459929503,
+    0.845643164225681,
+    0.16794289804370816,
+    0.10162406414747382,
+    0.14123839370037056,
+    0.003792191683109981,
+    1.0299547040985766,
+    0.026807856101721112,
+    0.17653371969231604,
+    0.12780393266727977,
+    0.8908493894032292,
+    0.05016778892928127,
+    0.934681359703447,
+    0.1104041562314812,
+    0.31259370205263126,
+    0.06284566928645681,
+    0.0476296971944526,
+    0.0830049159968845,
+    0.009159661389404805,
+    0.009991588429808441,
+    0.015528991567811172,
+    0.009214628598242817,
+    0.04463082981364765,
+    0.2761646624698818,
+    0.02775785294501277,
+    0.030920921663565613,
+    0.030880088364676584,
+    0.055419986988230405,
+    0.041834856384027466,
+    0.02589530670378627,
+    0.046540107091908624,
+    0.3004110613744119,
+    0.20301909742424815,
+    0.4951043096230534,
+    0.11858115408807053,
+    0.04279910991149764,
+    0.023470200843156975,
+    0.01592837521137288,
+    0.028320290449247595,
+    0.01914740566847937,
+    0.08423100623656579,
+    0.10575781800339631,
+    0.016729639837999192,
+    0.01928515125899576,
+    0.08169190304672652,
+    0.043987800607954874,
+    0.054514411329818525,
+    0.04298134155196387,
+    0.031085953544609714,
+    0.12615909276179177,
+    0.0003465282173637971,
+    0.058103130282949,
+    0.07365046853595525,
+    0.060615225341305666,
+    0.04588259821425726,
+    0.012813260692314313,
+    0.7798777201137593,
+    0.02613612797608842,
+    0.013461529716750041,
+    0.009893951634252595,
+    0.030991193644600953,
+    0.05620493774258541,
+    0.3699038744925965,
+    0.015097946393717242,
+    0.06271302769749793,
+    0.0020384128886200997,
+    0.03567165517083371,
+    0.014525490144668496,
+    0.020607956055678806,
+    0.0246435390331219,
+    0.019879489642093223,
+    0.019407494266871623,
+    0.11583263922549474,
+    0.03948876108912776,
+    0.5294244867375493,
+    0.1426857432967834,
+    0.009697385429695126,
+    0.00525992849031739,
+    0.00430141196125398,
+    0.005875039927428631,
+    0.005522219552694836,
+    0.0042607480963535544,
+    0.005011184230011202,
+    0.007821903345226908,
+    0.009009616491770123,
+    0.07680989084065051,
+    0.07186045769829646,
+    0.015555751145719514,
+    0.015630740713881576,
+    0.057320516556811474,
+    0.07343146368625852,
+    0.7843452939662691,
+    0.07344594465684656,
+    0.04994298205930179,
+    0.031135505320641476,
+    0.025933641798745768,
+    0.01973190434263985,
+    0.021311914846065032,
+    0.025391967733273624,
+    0.030199067305597543,
+    0.3226950750643045,
+    0.014203685630096484,
+    0.01534037036997655,
+    0.016453107333170788,
+    0.010525597809363562,
+    0.10166018086042491,
+    0.05537516038147018,
+    0.025057187459666765,
+    0.03937935331770495,
+    0.03732606414021839,
+    0.03623014247507323,
+    0.0303133933027351,
+    0.01190830530874745,
+    0.05028800045819346,
+    0.17635692976160655,
+    0.05953594686309811,
+    0.020222535641001925,
+    0.0805146256571518,
+    0.02373659967645878,
+    0.012165928750908704,
+    0.0514820122407643,
+    0.07815653280919697,
+    0.23201058369437041,
+    0.0340423547943379,
+    0.03484151181059308,
+    0.018298598649656068,
+    0.029716445173173824,
+    0.03187810305202435,
+    0.010038564502119844,
+    0.015603661528300027,
+    0.0546445315444071,
+    0.0205808711039938,
+    0.014522895203654958,
+    0.016252765900716146,
+    0.019648594042289334,
+    0.021480373184972493,
+    0.016468148859886997,
+    0.007782615606278065,
+    0.016094168571066846,
+    0.017228336077233373,
+    0.01051829618341627,
+    0.013373893984522116,
+    0.5939814038121429,
+    0.020783632669147317,
+    0.09311654260907076,
+    0.45806162186901805,
+    0.016262433777165904,
+    0.8009278300362112,
+    0.05345785152641949,
+    0.2849887196254366,
+    0.033647685486223135,
+    0.14550079382917516,
+    0.03663536045894266,
+    0.030880282999975885,
+    0.29087772423039293,
+    0.021630884822714493,
+    0.02556252999484156,
+    0.024271715891829745,
+    0.05392513908839965,
+    0.12206094837643991,
+    0.06168160301572301,
+    0.7690944309219785,
+    0.005753846170923199,
+    0.01336445751002951,
+    0.02106355972240177,
+    0.01879685972329176,
+    0.0952444313427708,
+    0.1078511795464463,
+    0.6469708160164086,
+    0.011508214196305674,
+    0.04112686678910598,
+    0.035610088844009874,
+    0.026485811067702324,
+    0.014370051474837841,
+    0.014242735913957073,
+    0.017811674662530638,
+    0.05585618250055378,
+    0.01738598064185313,
+    0.07195021868945746,
+    0.015339399943488055,
+    0.34467463670324133,
+    0.016179746130454448,
+    0.06440448684565248,
+    0.05608468433498269,
+    0.04424636779988501,
+    0.037440464051362185,
+    0.057664402696718915,
+    0.05762190400375552,
+    0.06924174005124464,
+    0.10847808154508215,
+    0.0904310617110173,
+    0.047983949715355446,
+    0.009818685405935522,
+    0.054721988898462984,
+    0.034677157404038546,
+    0.3509325669208246,
+    1.0268344467822377,
+    0.23944522020834375,
+    0.23057234097441315,
+    0.12663716357349866,
+    0.06110408862755362,
+    0.0706237379606926,
+    0.08926016309905949,
+    0.04690508445469457,
+    0.028732090191940274,
+    0.17809611583512075,
+    0.029989165393382068,
+    0.391596040835184,
+    0.12205539606742612,
+    0.29440576356307174,
+    0.16589103850643355,
+    0.006074718243210164,
+    1.0268328659759098,
+    0.02556053511771133,
+    0.04029260310233885,
+    0.041439782865155726,
+    0.10228632526932319,
+    0.08075810970675557,
+    0.09598294305539697,
+    0.39953051109714005,
+    0.029306409486832358,
+    0.09671994873655325,
+    0.1627823795415789,
+    0.02458907783680164,
+    0.05986464703306779,
+    0.09584181947018754,
+    0.11580850896272278,
+    0.12535825153862024,
+    0.11179598232834778,
+    0.058041800368261356,
+    0.05131909973307807,
+    0.0603260376812227,
+    0.05596616469177014,
+    0.23658290631261256,
+    0.0875715634398609,
+    0.40697930337242394,
+    0.04985868432498091,
+    0.2230670459299213,
+    0.06725351272770712,
+    0.4384349898078352,
+    0.08775397845174246,
+    0.3979923162137123,
+    0.04290208100438889,
+    0.013320545764006694,
+    0.04458140027621235
+};
+
+static const std::vector<double> turf_bearing = {
+    -63.16835850131531,
+    0,
+    -88.81417863186009,
+    -91.84236975943857,
+    -66.48043977763521,
+    95.21979003833424,
+    -100.30570881383704,
+    150.61043051772228,
+    -42.426806215464694,
+    -23.550372000573976,
+    -13.952505152879574,
+    -43.59833577993832,
+    132.99198010189937,
+    166.41929543157306,
+    177.20325520034712,
+    -179.08016176339177,
+    -170.23703380143226,
+    11.337660289434671,
+    -82.74731094370897,
+    63.53130497081162,
+    8.962738746772079,
+    9.37241746920313,
+    -168.57228731224598,
+    28.730760752589035,
+    31.624597764846637,
+    29.367864287830926,
+    40.81330085442227,
+    42.194625737959534,
+    54.716993037210045,
+    -109.61289479694872,
+    -105.95081303007647,
+    -97.35442495838333,
+    103.73738360872167,
+    128.63753291604394,
+    139.40255086492127,
+    154.353076115606,
+    172.41822883056525,
+    -173.00067170261374,
+    -157.88885299734986,
+    -153.5843194614746,
+    -135.57055814036255,
+    -113.78745742707413,
+    -92.43386994136272,
+    -80.19821514884795,
+    -62.824367973789435,
+    -39.24535094117481,
+    -19.378190579597625,
+    -6.122391240486928,
+    10.162381849878825,
+    16.628046997768607,
+    11.796298622071708,
+    9.259418658966705,
+    33.013988074027225,
+    95.42809952694313,
+    99.12772053947573,
+    114.05171960306723,
+    138.26425923091327,
+    115.39825807756951,
+    -78.13409883483345,
+    -78.57409383589719,
+    -87.160852199759,
+    -108.19195718984352,
+    86.91738524340066,
+    84.70017282115018,
+    87.95033104208615,
+    90.43302815253836,
+    78.02446742577152,
+    87.86117672643189,
+    -69.86932102730815,
+    -82.07107484952823,
+    -72.86553078555735,
+    -65.13553755018475,
+    -44.79817086959291,
+    -110.571105457802,
+    7.7069914618379975,
+    14.357081966766243,
+    37.06518971504373,
+    44.04525332938273,
+    66.87692305523359,
+    86.3047355297261,
+    107.98313958114178,
+    119.27773275782387,
+    133.08034139008478,
+    136.03334417898122,
+    147.83958090135633,
+    166.35653589386422,
+    -174.66648287441066,
+    -152.70026365512155,
+    -134.67606484413284,
+    -102.21019447457768,
+    -98.37013738611591,
+    -85.39045487355833,
+    -83.16251407128772,
+    -79.41426027366361,
+    -71.6199202393354,
+    25.647805187311675,
+    171.1662911122707,
+    175.31992210998703,
+    171.14075667901446,
+    168.46991110160218,
+    171.99557069100132,
+    166.22310505740552,
+    1.1490813990525728,
+    -160.4320410335643,
+    -163.99994946634425,
+    -165.7728900157161,
+    -173.45680597027817,
+    -170.84905103756142,
+    -174.09621979366605,
+    -175.5476650357732,
+    -178.24648292689753,
+    -178.90151317182918,
+    -172.65900564120977,
+    -167.57442915983086,
+    -155.7719187979583,
+    -147.18225435271103,
+    -144.4718825804975,
+    -132.58756100092145,
+    -127.58358614976032,
+    -124.36541206185082,
+    -117.43139970416347,
+    -114.09107335076804,
+    -98.50829769899121,
+    -93.15284638637799,
+    -92.50530269529919,
+    -94.47703726903666,
+    -100.11192008297043,
+    59.77360017983539,
+    9.143285027353551,
+    13.771320155516808,
+    18.804056386135507,
+    24.65786911308088,
+    -162.44500486120558,
+    -67.84560294942295,
+    -41.52913748098395,
+    -31.493999863996763,
+    -11.862722004156867,
+    4.911415384854547,
+    20.5768593094366,
+    39.328103571820634,
+    47.73104506840779,
+    60.04949187845642,
+    77.68453534325027,
+    92.16377287776062,
+    106.8766740367609,
+    129.48750446573763,
+    134.76457530705628,
+    148.07063441375706,
+    162.56674425873655,
+    167.60958213096342,
+    -147.58932438111154,
+    -0.35602290379352103,
+    36.377431696616014,
+    149.50345988748333,
+    88.36898545914883,
+    -12.223747274643541,
+    4.239696760480642,
+    -175.4876519466847,
+    0.5992644178179116,
+    0.6673420115819962,
+    0.2094907113015796,
+    -111.81827272749739,
+    0.6404507036839922,
+    91.57935182920652,
+    -88.72964175221959,
+    -72.73595760634777,
+    23.023787324470447,
+    21.284935274447214,
+    20.497437869075558,
+    26.023401004269186,
+    38.80671567232787,
+    55.538280861535505,
+    72.4357211583551,
+    81.25555219912327,
+    71.54335789800336,
+    -96.67318521343546,
+    -94.1256029846292,
+    -92.8904417068675,
+    -89.99983922215844,
+    -81.74515005128639,
+    -73.017109535514,
+    -56.65379972139568,
+    -75.85450215095052,
+    -117.43602194323526,
+    -0.5191133757264856,
+    138.78810984843733,
+    137.56824257563747,
+    123.6752409593202,
+    118.34970554664147,
+    104.79079949099777,
+    95.33306354879424,
+    88.48636023444747,
+    84.26539611797256,
+    -89.23804769018248,
+    126.44610739090022,
+    6.304981289653255,
+    9.538566926163998,
+    13.280042951632822,
+    19.166182380726028,
+    21.51585631114597,
+    -89.9996339244023,
+    -164.35486815306686,
+    -163.17151075342585,
+    -169.4719802936045,
+    -173.09313538953987,
+    -173.68544129286698,
+    -176.6550060133922,
+    -179.38201633291828,
+    19.85934450173753,
+    26.825916744943097,
+    30.042999793582226,
+    32.87625705680969,
+    30.58584499722022,
+    25.48436330531482,
+    -49.58528537111213,
+    -45.66818093662166,
+    -60.58696099977996,
+    -44.178097235571066,
+    -37.213574067968544,
+    -29.02801030830766,
+    -20.88386390872622,
+    -10.016986251287301,
+    -7.470516078862877,
+    6.345968960148908,
+    4.343209329511361,
+    -144.91638104371413,
+    91.78645944829398,
+    100.57490882565328,
+    115.0198771218778,
+    126.49515676679046,
+    132.9667450433102,
+    143.6768700122894,
+    152.57244080955854,
+    162.6386056371201,
+    174.5149571496929,
+    180,
+    -172.73016111884994,
+    -173.57809345551524,
+    -170.66439195019734,
+    -161.16292504839234,
+    -159.27915118031842,
+    -162.90191364007953,
+    6.149002598385885,
+    -178.25002252904207,
+    -179.67835798380287,
+    -171.71629870718354,
+    -163.02862431499696,
+    -152.95560774414605,
+    -145.55034082696017,
+    -138.50963007714628,
+    -130.96610418046026,
+    -110.60445245954395,
+    -63.488932754631335,
+    -58.5296285047684,
+    -40.784935262998765,
+    -33.4011304023945,
+    -15.899450270318724,
+    -11.98079922175284,
+    -8.147813628278488,
+    0.8158694642281521,
+    15.093060659786769,
+    22.923229163325363,
+    32.44078804116013,
+    42.447012241263664,
+    45.83427921173283,
+    48.52837549516453,
+    49.16371967470212,
+    46.12898587570745,
+    48.67322750744069,
+    -89.99993112361511,
+    -131.16855313987196,
+    -132.21634274729973,
+    -131.43505191524252,
+    -131.12876979883848,
+    -136.22759997049272,
+    -148.82348281194703,
+    -154.91921385645844,
+    -165.80042858245199,
+    -176.30209430550704,
+    175.72884637650225,
+    169.64893781173248,
+    164.32272447851253,
+    166.609539892841,
+    171.1155850861851,
+    166.3637807513156,
+    175.0886195159549,
+    178.0053467715306,
+    -173.15552476803634,
+    -163.24971275122377,
+    -153.06780391136738,
+    -140.2005052574728,
+    -130.17077601985082,
+    -118.29848203781941,
+    96.31992932289273,
+    93.37488183764101,
+    98.65620852739153,
+    -13.220894289645209,
+    90.78374679182464,
+    -122.38574263089491,
+    90.11906042024525,
+    90.91606631491278,
+    89.24226505678728,
+    87.1952301524552,
+    89.99989371956251,
+    92.89042347389294,
+    -73.7442223661134,
+    -116.5749747098209,
+    -106.68941539794253,
+    -96.5786003424879,
+    -90.23620894320432,
+    -89.42530845705083,
+    -89.99982105641459,
+    96.0164612641722,
+    97.77709140355806,
+    89.99996123049279,
+    93.32997836025105,
+    87.96524189628325,
+    90.86961377588838,
+    90.23605053342526,
+    -44.50763881494917,
+    -87.22999594921937,
+    -91.08466221917038,
+    -89.10502963081117,
+    -82.51948924863764,
+    -70.55890852242291,
+    -61.55042515193161,
+    -54.93400664520933,
+    -43.708432529297596,
+    -42.630819035108374,
+    -40.89066031737039,
+    -39.768718845646205,
+    74.90365235947708,
+    -164.2486209384613,
+    -166.49009116775852,
+    -170.9886716825588,
+    -173.2072838154825,
+    -176.56563073545988,
+    -177.67795564677132,
+    -179.256576114407,
+    177.6794175196906,
+    177.08641995168978,
+    -179.7039343413944,
+    -162.31174704216053,
+    -88.05239082476302,
+    104.83933395089112,
+    90.91884342553296,
+    89.99898193057349,
+    -89.65566421438635,
+    90.45177683075481,
+    90.60742069201243,
+    90.35190900335593,
+    15.252229486307309,
+    -176.88983601147055,
+    -170.29517886206932,
+    -167.69014730626628,
+    -163.75539093753457,
+    -160.78980004585748,
+    -162.40423641636087,
+    11.815918282011998,
+    -89.89521786054206,
+    -88.44037032865228,
+    -90.4221071958824,
+    -89.99998237874593,
+    89.64945709813418,
+    -97.7527834928843,
+    -95.70334593407169,
+    -92.4612675583479,
+    -91.68219351312248,
+    -90.94678497047079,
+    -90.39810804835399,
+    -163.10988605669783,
+    18.40425036657263,
+    18.419844554057384,
+    17.853582297033203,
+    12.289104432473655,
+    8.709879040159981,
+    2.2353614586368535,
+    1.0172614149903392,
+    -0.34171312935348624,
+    0.7663441543155729,
+    6.935793519460202,
+    9.538556916896354,
+    12.252956857370524,
+    18.19480908504452,
+    -175.0372577909854,
+    -89.34475877505189,
+    -158.31621119967375,
+    -74.8695322495171,
+    109.63776192527479,
+    92.36950183161946,
+    -10.475734036813332,
+    90.2902405855761,
+    -177.25427215646803,
+    -89.10855416703986,
+    -173.55458838862484,
+    90.5716881361661
+};
+
+static const std::vector<cr::point> turf_destination = {
+    { -96.92034100000001, 32.82927060622736 },
+    { -96.92060772614725, 32.829305975369245 },
+    { -96.92079439543319, 32.82931008237797 },
+    { -96.92109595102636, 32.829318926002884 },
+    { -96.92143033606274, 32.82932450415998 },
+    { -96.92175049436656, 32.82938581393253 },
+    { -96.92146736784431, 32.82936485157204 },
+    { -96.92172490097579, 32.82937161249924 },
+    { -96.9213630235027, 32.8285760913059 },
+    { -96.92177070843935, 32.82880428175528 },
+    { -96.92203788361117, 32.82899017678576 },
+    { -96.92233149855905, 32.82939076851167 },
+    { -96.92256548517682, 32.82946704822662 },
+    { -96.91818769656206, 32.82592900640833 },
+    { -96.91832325986564, 32.825805632710264 },
+    { -96.91849903664684, 32.82575891598141 },
+    { -96.91868196749337, 32.82564384425943 },
+    { -96.91898098457527, 32.82510240477685 },
+    { -96.91839818728636, 32.8283385839573 },
+    { -96.91939827432712, 32.82847636744433 },
+    { -96.91827631973166, 32.82907174007224 },
+    { -96.91834125479305, 32.82971268589303 },
+    { -96.91832704128093, 32.8307271881736 },
+    { -96.91985130136207, 32.82516722942136 },
+    { -96.91977856038616, 32.825603791320425 },
+    { -96.91984148408056, 32.8258148548345 },
+    { -96.91993702946877, 32.82599140014963 },
+    { -96.91991915091329, 32.826241406696084 },
+    { -96.91979779876095, 32.826579853154904 },
+    { -96.91558705439019, 32.82925571745485 },
+    { -96.91591658029526, 32.829282976817495 },
+    { -96.91661047207285, 32.829234607705295 },
+    { -96.92007967053509, 32.82895758586908 },
+    { -96.9200521621881, 32.82900388634131 },
+    { -96.92014087867756, 32.829045483451324 },
+    { -96.92024377268062, 32.82908435082749 },
+    { -96.92036379723118, 32.829119461406734 },
+    { -96.92049790317056, 32.829111787443004 },
+    { -96.92067803914178, 32.82898830051573 },
+    { -96.92138209750365, 32.82793197154348 },
+    { -96.9217141663508, 32.827713770769876 },
+    { -96.92187716351988, 32.82779766780548 },
+    { -96.92207102285543, 32.827881631620734 },
+    { -96.92226470339185, 32.82798563055431 },
+    { -96.92246216268975, 32.828102632325134 },
+    { -96.92264635970814, 32.82823460404209 },
+    { -96.92281225401825, 32.828382512213935 },
+    { -96.92295880519139, 32.828539322759674 },
+    { -96.92309097382822, 32.82870200101877 },
+    { -96.92319872369181, 32.82889451176149 },
+    { -96.92312705780591, 32.829556819195616 },
+    { -96.9232028626346, 32.82985088699453 },
+    { -96.9232411573597, 32.83037567828073 },
+    { -96.92269992821585, 32.83134715565532 },
+    { -96.9220470103152, 32.83141228122331 },
+    { -96.92175545672075, 32.831486016562685 },
+    { -96.92171723372269, 32.83156132277095 },
+    { -96.921734306369, 32.8316111604673 },
+    { -96.92164664653896, 32.831668489803576 },
+    { -96.9265483183977, 32.83265027046581 },
+    { -96.92685511412476, 32.832821461731555 },
+    { -96.92747508633266, 32.83298002241657 },
+    { -96.9302621268373, 32.832372910939625 },
+    { -96.92926537384224, 32.832561085283594 },
+    { -96.92859171846636, 32.832760503071036 },
+    { -96.92777413074916, 32.8329291215357 },
+    { -96.92643558565632, 32.833062897544984 },
+    { -96.92620707047061, 32.83326078761194 },
+    { -96.92146356644531, 32.83355674791104 },
+    { -96.92179503322653, 32.8337837342936 },
+    { -96.92204845102395, 32.83395270229553 },
+    { -96.9224428137804, 32.834186607151885 },
+    { -96.92272809550946, 32.834423403814895 },
+    { -96.92288827790685, 32.83466104696409 },
+    { -96.92494226054892, 32.83418049103243 },
+    { -96.92485328363847, 32.83519469016151 },
+    { -96.92485407643412, 32.835497598333895 },
+    { -96.92480870102905, 32.83574916926978 },
+    { -96.92475014863298, 32.83598835649724 },
+    { -96.92465640380966, 32.83618911335752 },
+    { -96.92456145502362, 32.83635039301763 },
+    { -96.92449329255402, 32.83647814848498 },
+    { -96.92439990743493, 32.836576332621924 },
+    { -96.92429828977875, 32.83663289816016 },
+    { -96.92403241904934, 32.83653879771671 },
+    { -96.92393731871984, 32.836543983800375 },
+    { -96.92392597882305, 32.8366104088374 },
+    { -96.92394738757146, 32.83667702518138 },
+    { -96.92399854388823, 32.83676378512602 },
+    { -96.92406844480034, 32.8368666409214 },
+    { -96.92418009097368, 32.837003544787805 },
+    { -96.92518146526312, 32.837036448933326 },
+    { -96.92660860730805, 32.83729030555763 },
+    { -96.9268684835029, 32.83747406688541 },
+    { -96.92709910606104, 32.837668685163564 },
+    { -96.92752148718918, 32.837947112682556 },
+    { -96.92582495878467, 32.84104130174476 },
+    { -96.92577181513958, 32.841024204874486 },
+    { -96.92570941035605, 32.84078977453039 },
+    { -96.92557675694083, 32.8403789633218 },
+    { -96.92548692274416, 32.840290723966085 },
+    { -96.92541287907572, 32.840206009324746 },
+    { -96.92530063370805, 32.84010277239874 },
+    { -96.92515475186458, 32.84469596626941 },
+    { -96.92515515797638, 32.84474454442302 },
+    { -96.9252083791398, 32.84460346030672 },
+    { -96.92526044659823, 32.84441666763957 },
+    { -96.9252473860237, 32.844274120357106 },
+    { -96.92524221144033, 32.84415777262634 },
+    { -96.92523092269901, 32.843916578859954 },
+    { -96.92523052056168, 32.84339549372804 },
+    { -96.9251830757581, 32.843048472162685 },
+    { -96.92512558963632, 32.842712469390584 },
+    { -96.92510010191579, 32.842557440932126 },
+    { -96.92510061543786, 32.842415342624996 },
+    { -96.92518115035102, 32.84226313063035 },
+    { -96.9252757385188, 32.84217676144705 },
+    { -96.92544139007872, 32.84202419192918 },
+    { -96.92565814381041, 32.84192937929272 },
+    { -96.92571903404281, 32.84197028113293 },
+    { -96.92585506965108, 32.841975855439806 },
+    { -96.92612027958023, 32.84195406060516 },
+    { -96.92638469759416, 32.84195185543719 },
+    { -96.92700035587634, 32.84199419917395 },
+    { -96.92771828543378, 32.84208705149566 },
+    { -96.92815651411966, 32.842196372537174 },
+    { -96.92850407135272, 32.84229412289962 },
+    { -96.92871998933195, 32.84237126366221 },
+    { -96.92303556750609, 32.845222756364045 },
+    { -96.92265144507935, 32.84674456312207 },
+    { -96.9222967307011, 32.84767464651239 },
+    { -96.92189950489244, 32.8484749696396 },
+    { -96.92172276419579, 32.848689496153796 },
+    { -96.9237410893001, 32.843108190296135 },
+    { -96.923802546131, 32.84328701670827 },
+    { -96.92374965829724, 32.843472940765764 },
+    { -96.9236514626933, 32.84363092836846 },
+    { -96.92353000280231, 32.84379494600556 },
+    { -96.92338332178431, 32.84398896076638 },
+    { -96.9232224556523, 32.84413994035114 },
+    { -96.92288446231687, 32.844442853078014 },
+    { -96.92244837426914, 32.8447656678973 },
+    { -96.92217622162691, 32.8449243543985 },
+    { -96.92185905928895, 32.84505088281731 },
+    { -96.92158293218587, 32.84514022404786 },
+    { -96.92127788623063, 32.84519234965051 },
+    { -96.92104596927354, 32.84522723186053 },
+    { -96.92084223019, 32.84527384359657 },
+    { -96.92059571034834, 32.84523815846969 },
+    { -96.92039946444064, 32.84522115078961 },
+    { -96.92018153243328, 32.84508279557485 },
+    { -96.92293075844712, 32.8413060685728 },
+    { -96.92278981214417, 32.844490946195606 },
+    { -96.91725748845279, 32.85068440564823 },
+    { -96.91617826911245, 32.84945342488996 },
+    { -96.91492269293347, 32.84954698255384 },
+    { -96.91507279822012, 32.85085305805673 },
+    { -96.91489851558394, 32.85094963157779 },
+    { -96.91559254022775, 32.84177868407015 },
+    { -96.91541578881139, 32.842077197188324 },
+    { -96.91521892350433, 32.84371915343081 },
+    { -96.91503791956701, 32.844920536056705 },
+    { -96.92370969579733, 32.84199332911104 },
+    { -96.92352559723263, 32.84249151740852 },
+    { -96.9133495208793, 32.842304086578224 },
+    { -96.91435055467473, 32.84236802303858 },
+    { -96.91736376818267, 32.843241314011124 },
+    { -96.91691918097388, 32.843797947525246 },
+    { -96.91655185513237, 32.84423091241846 },
+    { -96.91605785663661, 32.84496119834133 },
+    { -96.91583122001299, 32.845063795761554 },
+    { -96.91558001680603, 32.84515969596507 },
+    { -96.91525830338438, 32.84526189106002 },
+    { -96.91497913504723, 32.84530737397885 },
+    { -96.9143215696874, 32.84538613848035 },
+    { -96.91133267086113, 32.84618717915156 },
+    { -96.91144147769786, 32.84617049140981 },
+    { -96.91158505725988, 32.84616007150336 },
+    { -96.91172846628058, 32.84615291651313 },
+    { -96.91213476159362, 32.84615702435345 },
+    { -96.912391, 32.84621239377265 },
+    { -96.91246923814964, 32.84627902435345 },
+    { -96.91269853223814, 32.84650491651311 },
+    { -96.91562893644198, 32.84715807150331 },
+    { -96.91737052114979, 32.846307491409796 },
+    { -96.91723228122223, 32.85074617915096 },
+    { -96.91621037304874, 32.84992913847948 },
+    { -96.91571580146685, 32.84962737397773 },
+    { -96.9153216256599, 32.84948989105859 },
+    { -96.91498690323063, 32.84939869596327 },
+    { -96.91450969112039, 32.84930779575933 },
+    { -96.91412204438035, 32.84926319833858 },
+    { -96.9130380189888, 32.84925191241467 },
+    { -96.9117296694325, 32.849312947520374 },
+    { -96.91172705571321, 32.84927831400496 },
+    { -96.91138023411317, 32.849136023030674 },
+    { -96.91110422918695, 32.84982408656827 },
+    { -96.91084713208613, 32.850169517397084 },
+    { -96.91053498353314, 32.85059932909671 },
+    { -96.91020684510828, 32.85091453604562 },
+    { -96.909908771174, 32.851122153415716 },
+    { -96.9110838227085, 32.85106719716819 },
+    { -96.91091104294216, 32.851006684047555 },
+    { -96.91091850811969, 32.85044663157913 },
+    { -96.91089125672022, 32.849733058059954 },
+    { -96.91079932847259, 32.84912698255514 },
+    { -96.9106847733917, 32.84864942489266 },
+    { -96.91052563309422, 32.848464405656216 },
+    { -96.9104503638796, 32.84138094620757 },
+    { -96.91019122863675, 32.84152706857188 },
+    { -96.909963680057, 32.84155779559022 },
+    { -96.90974976319653, 32.84155515080656 },
+    { -96.90941051524207, 32.841707158486976 },
+    { -96.90894698098482, 32.84205784361321 },
+    { -96.907088047852, 32.8449732318619 },
+    { -96.90705712898402, 32.844972349651776 },
+    { -96.90738505824653, 32.845275224047036 },
+    { -96.90725393055232, 32.845190882816425 },
+    { -96.90737174860608, 32.84532535439583 },
+    { -96.9073195827836, 32.84533166789337 },
+    { -96.9072824639789, 32.84539385307118 },
+    { -96.90723443684865, 32.84549894034094 },
+    { -96.90713155058394, 32.845570960754024 },
+    { -96.90702084565024, 32.84563794599061 },
+    { -96.9067482915646, 32.846564928343774 },
+    { -96.90658305728276, 32.846808940736665 },
+    { -96.90970849593005, 32.84280201671265 },
+    { -96.90805395125876, 32.84264819030043 },
+    { -96.90782578893621, 32.84251649621324 },
+    { -96.90765104983556, 32.84237896970015 },
+    { -96.90749277157009, 32.84223664656806 },
+    { -96.90732799202755, 32.842079563171204 },
+    { -96.90717674658113, 32.84191675639983 },
+    { -96.90704206968707, 32.84175826366903 },
+    { -96.90691499740588, 32.84158912290766 },
+    { -96.90679856537491, 32.841391372546596 },
+    { -96.90669280511362, 32.84118105150652 },
+    { -96.9066938088171, 32.84036519919393 },
+    { -96.90667954376929, 32.839590855466795 },
+    { -96.90660899268886, 32.8393190606389 },
+    { -96.9065682357046, 32.83905085547807 },
+    { -96.90669333896665, 32.83843228118014 },
+    { -96.90683531022513, 32.83766337935074 },
+    { -96.9058493401867, 32.844535191894416 },
+    { -96.90579009265895, 32.8437347614251 },
+    { -96.90571275338846, 32.84314413061774 },
+    { -96.90568335053055, 32.8427243426205 },
+    { -96.90568992027882, 32.84235744093508 },
+    { -96.90571448391348, 32.84205446940046 },
+    { -96.90577507033056, 32.84175047218241 },
+    { -96.90588970181872, 32.841432493758276 },
+    { -96.90607139760981, 32.84110657890376 },
+    { -96.90924427251379, 32.83993677269292 },
+    { -96.90932412469623, 32.839844120427756 },
+    { -96.90941109238025, 32.839765667714516 },
+    { -96.9094761887729, 32.83972646038609 },
+    { -96.90949143753902, 32.83965354450662 },
+    { -96.9097457551243, 32.840379966340876 },
+    { -96.90982829424877, 32.84071377238854 },
+    { -96.90982905264774, 32.840783009315054 },
+    { -96.90978899510543, 32.840982723954376 },
+    { -96.9096541510239, 32.84115196330865 },
+    { -96.9094755291208, 32.84129677452172 },
+    { -96.90927714334165, 32.84137120486853 },
+    { -96.9091700108835, 32.84129430174039 },
+    { -96.90876609180499, 32.84145311262188 },
+    { -96.90733733141684, 32.8423466850824 },
+    { -96.90684390666796, 32.8425400667973 },
+    { -96.90667976396954, 32.842509305466734 },
+    { -96.90602783642515, 32.84283044883231 },
+    { -96.9062802255586, 32.84267354468892 },
+    { -96.90637988293022, 32.84244464082416 },
+    { -96.90679282812866, 32.84197678503523 },
+    { -96.90742804933328, 32.84135502510003 },
+    { -96.9093096344923, 32.83982640878158 },
+    { -96.90957633247281, 32.839448983750096 },
+    { -96.90978728295761, 32.83902479767383 },
+    { -96.90989146055402, 32.8387198981243 },
+    { -96.90999388620241, 32.838305332592356 },
+    { -96.91004354245484, 32.83786414846141 },
+    { -96.910066394355, 32.83761939299617 },
+    { -96.91007046155549, 32.8373271133384 },
+    { -96.90994976743183, 32.83670035648537 },
+    { -96.90993922639949, 32.83636716925954 },
+    { -96.90995885480693, 32.83608559832425 },
+    { -96.90996464686559, 32.835791690151794 },
+    { -96.90999659070908, 32.83546449101174 },
+    { -96.91004166908012, 32.83512104695675 },
+    { -96.91011885853125, 32.83482440380857 },
+    { -96.91020213813562, 32.8346086071453 },
+    { -96.91034250605827, 32.834331702289695 },
+    { -96.91052593504799, 32.834065734289304 },
+    { -96.91068039981232, 32.83385874790652 },
+    { -96.91087788560367, 32.83365678760608 },
+    { -96.90463542953506, 32.83292489754698 },
+    { -96.90449088650593, 32.83277112153798 },
+    { -96.90358630936747, 32.83250350307465 },
+    { -96.90479021695444, 32.83637208523084 },
+    { -96.90470246266294, 32.836230910887174 },
+    { -96.91202899207734, 32.8322360224265 },
+    { -96.91154896132278, 32.83209846174101 },
+    { -96.90859475679387, 32.83192227047514 },
+    { -96.90833234079028, 32.83179248980202 },
+    { -96.90687768221198, 32.83172416046592 },
+    { -96.90658876308076, 32.83159332277057 },
+    { -96.90636454683248, 32.8314500165631 },
+    { -96.90946092710227, 32.83205428121599 },
+    { -96.90977902424702, 32.83184115564981 },
+    { -96.91015472158404, 32.83165067826693 },
+    { -96.91052898267965, 32.83150288697713 },
+    { -96.9112247739368, 32.83137981917697 },
+    { -96.91265206016878, 32.83127151173788 },
+    { -96.91343580663084, 32.831154000995156 },
+    { -96.90537803849678, 32.83031332274312 },
+    { -96.90544558911877, 32.830192512197605 },
+    { -96.90543348303062, 32.83008060402599 },
+    { -96.90534168189792, 32.82995963230952 },
+    { -96.90527614279657, 32.829857630539124 },
+    { -96.90439482744506, 32.82973863160623 },
+    { -96.90338069160265, 32.829630667791726 },
+    { -96.90837537183168, 32.83367677072692 },
+    { -96.90864247408625, 32.83358197150447 },
+    { -96.9092286278605, 32.833477300486074 },
+    { -96.90975778683836, 32.833386787416 },
+    { -96.91018890496235, 32.8333244613814 },
+    { -96.91048593761097, 32.833276350803445 },
+    { -96.91077383813835, 32.833248483428406 },
+    { -96.91108555891405, 32.83325388631932 },
+    { -96.911656037352, 32.83353258584669 },
+    { -96.91194125915716, 32.833565607685266 },
+    { -96.91260613703052, 32.83397497679704 },
+    { -96.91287366825213, 32.834003717435394 },
+    { -96.90947673989618, 32.83473585312356 },
+    { -96.9096893960709, 32.83452340666632 },
+    { -96.91001755333926, 32.83389040012315 },
+    { -96.91028013353335, 32.833324854811124 },
+    { -96.91050608380527, 32.83286479129949 },
+    { -96.91070135504911, 32.83246622940192 },
+    { -96.91089890631574, 32.831888188170744 },
+    { -96.91108067612203, 32.83131268588944 },
+    { -96.91122561582051, 32.83063574006906 },
+    { -96.91134268123285, 32.82960936744224 },
+    { -96.91152479752446, 32.828746583956615 },
+    { -96.91185890321435, 32.82828840477211 },
+    { -96.9121429460756, 32.828246844255986 },
+    { -96.91175689101942, 32.828078915978715 },
+    { -96.91156667517494, 32.82803463270799 },
+    { -96.90799324737107, 32.82799800640653 },
+    { -96.91916255109285, 32.82801904822771 },
+    { -96.91678353408332, 32.82797076851257 },
+    { -96.91450013877316, 32.827920176786314 },
+    { -96.91332930884246, 32.827887281755665 },
+    { -96.91334197954883, 32.82839409130596 },
+    { -96.91356812298534, 32.82773961249966 },
+    { -96.91391466280625, 32.8269308515725 },
+    { -96.91420753589344, 32.82650381393292 },
+    { -96.91447968982843, 32.82624350416024 },
+    { -96.915293077956, 32.8247219260031 },
+    { -96.91557662496521, 32.82445808237808 },
+    { -96.91490527680895, 32.82789997536924 },
+    { -96.91639800000002, 32.82790060622736 },
+    { -96.91973372334664, 32.82797397536925 },
+    { -96.92169538978655, 32.827967082377995 },
+    { -96.92194694254597, 32.82797392600294 },
+    { -96.91114632526379, 32.82803950416009 },
+    { -96.91160348003399, 32.82802081393272 },
+    { -96.91221835065487, 32.82799985157229 },
+    { -96.91284688086124, 32.82800161249959 },
+    { -96.9141260137614, 32.827995091306086 },
+    { -96.91517469340017, 32.82800628175562 },
+    { -96.91638586344432, 32.82802617678628 },
+    { -96.91781138884836, 32.824617768514706 },
+    { -96.91789537076589, 32.82489904823005 },
+    { -96.91775069192848, 32.82575800640849 },
+    { -96.91739830014022, 32.82718763270885 },
+    { -96.91752308915034, 32.82744291597945 },
+    { -96.91760604628695, 32.82801684425629 },
+    { -96.91774511911717, 32.828922404771156 },
+    { -96.91790124953417, 32.830010583954504 },
+    { -96.91808638066573, 32.831187367439334 },
+    { -96.91824645048688, 32.83224474006578 },
+    { -96.91834638886598, 32.832817685886084 },
+    { -96.91842915877513, 32.83333018816722 },
+    { -96.91846471341049, 32.83392022939806 },
+    { -96.9184489944202, 32.83446079129487 },
+    { -96.91883781971728, 32.83240685481398 },
+    { -96.91994337233697, 32.83248340012787 },
+    { -96.9217193101751, 32.82915340668562 },
+    { -96.92239995502872, 32.82934285314428 },
+    { -96.92031602448525, 32.828743717456945 },
+    { -96.91975955095923, 32.82879597681961 },
+    { -96.92077369032383, 32.83275160768903 },
+    { -96.91999391775727, 32.83282958585012 },
+    { -96.9203551842353, 32.829339886339575 },
+    { -96.92096990474985, 32.82943248344921 },
+    { -96.92113979465543, 32.82940235082567 },
+    { -96.9208148234328, 32.8294894614045 }
+};
+
+static const std::vector<double> turf_lineDistance = {
+    0.04662454909427901,
+    0.0068391514197623125,
+    0.09985216775589113,
+    0.1114897011108262,
+    0.07753561751121403,
+    0.173873577625755,
+    0.14681366156746842,
+    0.06837599656020085,
+    0.43073382183261627,
+    0.15584656488988174,
+    0.06961927450155198,
+    0.4176778492245252,
+    0.11346010319030365,
+    0.4069191477510672,
+    0.0912702817480534,
+    0.21057858475480964,
+    0.9731217926415133,
+    0.3421517057131934,
+    0.24832380027187234,
+    0.345931459929503,
+    0.269566962191182,
+    0.003792191683109981,
+    0.33114550846131696,
+    0.05016778892928127,
+    0.1104041562314812,
+    0.2820059822767088,
+    0.2592491201412077,
+    0.20301909742424815,
+    0.3324775424083908,
+    0.016729639837999192,
+    0.2542614100810735,
+    0.2514112112841453,
+    0.13668774071427742,
+    0.3699064116077255,
+    0.5100540014631532,
+    0.27709292806311164,
+    0.7806905867697003,
+    0.7768297872678829,
+    0.11390017527821808,
+    0.016262433777165904,
+    0.585110693926173,
+    0.30913282118994834,
+    0.26207433401586333,
+    0.32168722472380185,
+    0.6017929391701553,
+    0.009818685405935522,
+    0.3856097243248631,
+    0.5966547247562556,
+    0.44360635693488976,
+    0.5884269163801416,
+    0.3863202991166816,
+    1.0477201274090444,
+    0.0875715634398609,
+    0.04985868432498091,
+    0.06725351272770712,
+    0.08775397845174246,
+    0.04290208100438889,
+    0.04458140027621235
+};
+
+static const std::vector<double> turf_area = {
+    0.00001385291315291015,
+    0.00038253063343961127,
+    0.0004601665282670179,
+    0.000025503489092274364,
+    0.000595225685418049,
+    0.0000274562733203963,
+    0.010106783304640774,
+    0.001104280981730458,
+    0.00007467453869082208,
+    0.00026115590644638464,
+    0.0004233598602508744,
+    0.010634164210050902,
+    0.0001950421991985674,
+    0.00045308678876159587,
+    0.11642042926261091,
+    0.0023790522112468416,
+    0.008515769374449783,
+    0.007485271287917676,
+    0.0000991431197074571,
+    0.006085169973921119,
+    0.004123438747704956,
+    0.010246920654428558,
+    0.0017456776108892168,
+    0.0012524502918429697,
+    0.0002985554527856464,
+    0.013319422885021871,
+    0.03301062700761473,
+    0.005952119850683508,
+    0.07276896988546715,
+    0.044671110786017286,
+    0.00008921566232195025,
+    0.0011521493461515583,
+    0.002598288702578828,
+    0.00017084098623693146,
+    0.009460656476931052,
+    0.008810544363699217,
+    0.00009774280666531308,
+    0.000016747619827861367,
+    0.005292114515450739,
+    0.00050350329460907,
+    0.0013371547851014247,
+    0.017404511466653897
+};
+
+static const std::vector<double> turf_along_dist = {
+    0.023312274547139505,
+    0.0034195757098811562,
+    0.049926083877945567,
+    0.0557448505554131,
+    0.038767808755607015,
+    0.0869367888128775,
+    0.07340683078373421,
+    0.034187998280100426,
+    0.21536691091630814,
+    0.07792328244494087,
+    0.03480963725077599,
+    0.2088389246122626,
+    0.05673005159515183,
+    0.2034595738755336,
+    0.0456351408740267,
+    0.10528929237740482,
+    0.48656089632075666,
+    0.1710758528565967,
+    0.12416190013593617,
+    0.1729657299647515,
+    0.134783481095591,
+    0.0018960958415549904,
+    0.16557275423065848,
+    0.025083894464640634,
+    0.0552020781157406,
+    0.1410029911383544,
+    0.12962456007060386,
+    0.10150954871212407,
+    0.1662387712041954,
+    0.008364819918999596,
+    0.12713070504053675,
+    0.12570560564207264,
+    0.06834387035713871,
+    0.18495320580386276,
+    0.2550270007315766,
+    0.13854646403155582,
+    0.39034529338485013,
+    0.38841489363394144,
+    0.05695008763910904,
+    0.008131216888582952,
+    0.2925553469630865,
+    0.15456641059497417,
+    0.13103716700793167,
+    0.16084361236190092,
+    0.30089646958507765,
+    0.004909342702967761,
+    0.19280486216243156,
+    0.2983273623781278,
+    0.22180317846744488,
+    0.2942134581900708,
+    0.1931601495583408,
+    0.5238600637045222,
+    0.04378578171993045,
+    0.024929342162490455,
+    0.03362675636385356,
+    0.04387698922587123,
+    0.021451040502194443,
+    0.022290700138106176
+};
+
+static const std::vector<cr::point> turf_along = {
+    { -96.92058074705263, 32.838295790638604 },
+    { -96.92038500000224, 32.838300500005154 },
+    { -96.92017837949811, 32.837840876146984 },
+    { -96.91575185809616, 32.834193910150304 },
+    { -96.91550349979606, 32.83693300067325 },
+    { -96.91447049297071, 32.838291837950294 },
+    { -96.91528382138036, 32.83401702016945 },
+    { -96.91074827033752, 32.837025468206356 },
+    { -96.91465325332314, 32.83491180557744 },
+    { -96.9133254981959, 32.83668815734806 },
+    { -96.91774498947463, 32.8373234997933 },
+    { -96.91858548156746, 32.8367137123682 },
+    { -96.912125005592, 32.837061935308064 },
+    { -96.91369409219625, 32.83774164388782 },
+    { -96.91639766393256, 32.837037707584614 },
+    { -96.91504330753082, 32.83916332521944 },
+    { -96.91553969265065, 32.83839013773005 },
+    { -96.91430070726516, 32.841204555275795 },
+    { -96.91571233411688, 32.837779806500336 },
+    { -96.9177544997986, 32.83499800000052 },
+    { -96.91166706734954, 32.841629875937976 },
+    { -96.9107185000003, 32.84265700000001 },
+    { -96.91156370689538, 32.83493146645441 },
+    { -96.92040000000762, 32.83366850000004 },
+    { -96.91099049992684, 32.83367300138629 },
+    { -96.91421262070213, 32.83569407895492 },
+    { -96.91178370739728, 32.83716800028003 },
+    { -96.91715300456607, 32.83775950369486 },
+    { -96.9169767353908, 32.840679780152996 },
+    { -96.91422649999899, 32.840554000031844 },
+    { -96.91397243336206, 32.841584696234726 },
+    { -96.91523149763671, 32.84157652148576 },
+    { -96.91515150426642, 32.83399134463128 },
+    { -96.9142729703425, 32.83879948063655 },
+    { -96.9156392575161, 32.835658314541256 },
+    { -96.91543436762962, 32.83921014952233 },
+    { -96.91983675113876, 32.84033226350925 },
+    { -96.92009207607055, 32.840359219198234 },
+    { -96.91380542577559, 32.836522062530115 },
+    { -96.91423699999902, 32.840453000030095 },
+    { -96.91825697483056, 32.836559607150164 },
+    { -96.91973317221228, 32.83716163055561 },
+    { -96.91180206194203, 32.83642316543709 },
+    { -96.91691026889121, 32.84079238934942 },
+    { -96.91491045374221, 32.840000370933915 },
+    { -96.9150394999991, 32.83688750001095 },
+    { -96.91246302385605, 32.83675801387829 },
+    { -96.91819499264128, 32.8367903863771 },
+    { -96.91518494007596, 32.83533040554249 },
+    { -96.91823942303637, 32.83693311262287 },
+    { -96.91246139013954, 32.83690233470654 },
+    { -96.91460659817584, 32.83801219845079 },
+    { -96.91478449997625, 32.840559500872736 },
+    { -96.91711949983032, 32.83722250026362 },
+    { -96.91476949994939, 32.83659450051385 },
+    { -96.91479349998943, 32.84045600087646 },
+    { -96.91475749999225, 32.836883000209426 },
+    { -96.91476449999463, 32.83676500022616 }
+};
+
+static const std::vector<double> turf_lineSlice = {
+    0.018676803463204973,
+    0.0027403004691342625,
+    0.0398660924057463,
+    0.04446856326668934,
+    0.031068781600570992,
+    0.06935062861161241,
+    0.05864407770725445,
+    0.02738946433808026,
+    0.17194340067724667,
+    0.062425250268892694,
+    0.027897179178562482,
+    0.16737293529254177,
+    0.04543404915442931,
+    0.1626655495109919,
+    0.036564726727473594,
+    0.08399080442136823,
+    0.3888893870284878,
+    0.13649098383658884,
+    0.09926948806782267,
+    0.13795991467073365,
+    0.10778696255372587,
+    0.0015123931765971925,
+    0.1320632508079359,
+    0.020007277614733015,
+    0.04424096972304277,
+    0.11264746401401557,
+    0.10385609012115837,
+    0.08127435006240627,
+    0.13303959829411355,
+    0.006704402992819479,
+    0.10142852122895935,
+    0.10028174144491304,
+    0.054573146193032135,
+    0.14766725949326992,
+    0.20376574794349672,
+    0.11058823108803342,
+    0.31189004060932496,
+    0.3103422255762966,
+    0.04563922619445161,
+    0.006517162427091035,
+    0.23447174477127802,
+    0.12386733468968403,
+    0.10502105512101395,
+    0.12872246637948387,
+    0.2400138878407706,
+    0.003934657129647942,
+    0.1545266007655544,
+    0.23909936135356857,
+    0.17696967699870225,
+    0.23580214129066726,
+    0.15480959152734855,
+    0.41791703759808313,
+    0.035094313148852196,
+    0.01997359910854999,
+    0.026950444653916276,
+    0.03516739283887676,
+    0.01719229231376514,
+    0.0178652399166501
+};
+
+static const std::vector<cr::box> turf_bufferPoint = {
+    {{ -96.92206300843843, 32.83681412509083 }, { -96.91861893543, 32.83970785132817 }},
+    {{ -96.92214300909791, 32.836848125090825 }, { -96.91869893477045, 32.839741851328164 }},
+    {{ -96.92214300909791, 32.836848125090825 }, { -96.91869893477045, 32.839741851328164 }},
+    {{ -96.92225800913668, 32.836850125090805 }, { -96.91881393473163, 32.83974385132815 }},
+    {{ -96.9224060090591, 32.836846125090815 }, { -96.91896193480923, 32.83973985132816 }},
+    {{ -96.92254001000953, 32.83689512509079 }, { -96.91909593385867, 32.83978885132814 }},
+    {{ -96.92207100931128, 32.83685912509082 }, { -96.91862693455705, 32.83975285132816 }},
+    {{ -96.92214300909791, 32.836848125090825 }, { -96.91869893477045, 32.839741851328164 }},
+    {{ -96.92159599327083, 32.83603212509119 }, { -96.91815195059978, 32.838925851328526 }},
+    {{ -96.92181899724693, 32.836237125091095 }, { -96.9183749466231, 32.83913085132843 }},
+    {{ -96.92190200035026, 32.83639712509101 }, { -96.91845794351933, 32.83929085132836 }},
+    {{ -96.92201200756558, 32.836769125090846 }, { -96.91856793630295, 32.83966285132819 }},
+    {{ -96.92206300843843, 32.83681412509083 }, { -96.91861893543, 32.83970785132817 }},
+    {{ -96.91750293916103, 32.83324212509243 }, { -96.91405900471734, 32.83613585132978 }},
+    {{ -96.91745693605817, 32.833082125092524 }, { -96.91401300782061, 32.83597585132986 }},
+    {{ -96.91745193439041, 32.83299612509255 }, { -96.91400800948864, 32.83588985132989 }},
+    {{ -96.91745493134579, 32.832839125092626 }, { -96.91401101253369, 32.835732851329965 }},
+    {{ -96.91757491998197, 32.83225312509288 }, { -96.91413102389916, 32.83514685133023 }},
+    {{ -96.91681398182763, 32.83544212509144 }, { -96.91336996204461, 32.83833585132879 }},
+    {{ -96.91763698353438, 32.83553012509141 }, { -96.91419296033762, 32.83842385132875 }},
+    {{ -96.91633899406605, 32.836073125091154 }, { -96.91289494980445, 32.8389668513285 }},
+    {{ -96.91622900543202, 32.836659125090904 }, { -96.91278493843684, 32.83955285132824 }},
+    {{ -96.91604102399457, 32.83761612509046 }, { -96.91259691987165, 32.840509851327816 }},
+    {{ -96.91739291499829, 32.831996125093006 }, { -96.91394902888356, 32.834889851330345 }},
+    {{ -96.91714892225083, 32.83237012509284 }, { -96.91370502162997, 32.83526385133019 }},
+    {{ -96.91704192508207, 32.83251612509276 }, { -96.91359801879831, 32.8354098513301 }},
+    {{ -96.91696892719582, 32.83262512509271 }, { -96.91352501668426, 32.835518851330065 }},
+    {{ -96.91678393068645, 32.83280512509264 }, { -96.91334001319315, 32.83569885132999 }},
+    {{ -96.91649693584488, 32.833071125092516 }, { -96.91305300803398, 32.83596485132987 }},
+    {{ -96.9121219862885, 32.83567212509135 }, { -96.90867795758311, 32.83856585132869 }},
+    {{ -96.91228898531874, 32.83562212509136 }, { -96.90884495855302, 32.838515851328715 }},
+    {{ -96.91282198283616, 32.83549412509143 }, { -96.90937796103594, 32.83838785132877 }},
+    {{ -96.91613197587343, 32.83513512509158 }, { -96.9126879679997, 32.838028851328936 }},
+    {{ -96.91594697513642, 32.835097125091615 }, { -96.91250296873679, 32.83799085132895 }},
+    {{ -96.91587997426367, 32.83505212509162 }, { -96.91243596960967, 32.837945851328975 }},
+    {{ -96.91582897329396, 32.835002125091656 }, { -96.91238497057954, 32.837895851328994 }},
+    {{ -96.91579697220784, 32.83494612509167 }, { -96.91235297166578, 32.837839851329015 }},
+    {{ -96.915780970249, 32.83484512509171 }, { -96.9123369736249, 32.83773885132906 }},
+    {{ -96.91581296600165, 32.83462612509182 }, { -96.91236897787286, 32.83751985132916 }},
+    {{ -96.91637094362142, 32.833472125092335 }, { -96.91292700025633, 32.83636585132968 }},
+    {{ -96.91655893745447, 32.833154125092484 }, { -96.91311500642416, 32.83604785132982 }},
+    {{ -96.9165799371054, 32.83313612509249 }, { -96.91313600677327, 32.83602985132983 }},
+    {{ -96.91663393671753, 32.8331161250925 }, { -96.91319000716118, 32.836009851329834 }},
+    {{ -96.91668993667875, 32.83311412509251 }, { -96.91324600719997, 32.83600785132984 }},
+    {{ -96.91675193685329, 32.83312312509249 }, { -96.91330800702542, 32.83601685132983 }},
+    {{ -96.91680293727993, 32.833145125092486 }, { -96.91335900659871, 32.83603885132984 }},
+    {{ -96.91683793797807, 32.833181125092466 }, { -96.91339400590047, 32.83607485132981 }},
+    {{ -96.91685593881195, 32.83322412509245 }, { -96.91341200506646, 32.836117851329796 }},
+    {{ -96.91686193972342, 32.83327112509243 }, { -96.91341800415486, 32.836164851329784 }},
+    {{ -96.91684594117791, 32.8333461250924 }, { -96.9134020027002, 32.836239851329736 }},
+    {{ -96.9166529517084, 32.83388912509215 }, { -96.91320899216815, 32.83678285132949 }},
+    {{ -96.9166099550635, 32.834062125092075 }, { -96.91316598881261, 32.836955851329414 }},
+    {{ -96.91653196285982, 32.83446412509189 }, { -96.91308798101515, 32.83735785132922 }},
+    {{ -96.91587697928689, 32.83531112509151 }, { -96.9124329645857, 32.83820485132886 }},
+    {{ -96.91511297810382, 32.83525012509153 }, { -96.91166896576897, 32.83814385132888 }},
+    {{ -96.91471297705651, 32.83519612509156 }, { -96.91126896681644, 32.83808985132891 }},
+    {{ -96.91456897600918, 32.83514212509158 }, { -96.9111249678639, 32.838035851328925 }},
+    {{ -96.91448297443822, 32.83506112509162 }, { -96.9110389694351, 32.83795485132896 }},
+    {{ -96.91429497298361, 32.834986125091646 }, { -96.9108509708899, 32.83787985132899 }},
+    {{ -96.91909898943054, 32.83583412509127 }, { -96.91565495444063, 32.83872785132861 }},
+    {{ -96.91931099012878, 32.835870125091255 }, { -96.9158669537423, 32.83876385132859 }},
+    {{ -96.91983899055546, 32.83589212509124 }, { -96.91639495331553, 32.838785851328595 }},
+    {{ -96.92253697610617, 32.83514712509158 }, { -96.91909296776691, 32.83804085132892 }},
+    {{ -96.9214539770565, 32.83519612509156 }, { -96.91800996681643, 32.83808985132891 }},
+    {{ -96.9206969782008, 32.835255125091535 }, { -96.91725296567199, 32.83814885132888 }},
+    {{ -96.91979897872444, 32.83528212509151 }, { -96.91635496514823, 32.838175851328856 }},
+    {{ -96.9183829785499, 32.83527312509153 }, { -96.91493896532283, 32.838166851328864 }},
+    {{ -96.91807997959722, 32.8353271250915 }, { -96.91463596427536, 32.83822085132884 }},
+    {{ -96.91326498252585, 32.835478125091434 }, { -96.9098209613463, 32.83837185132878 }},
+    {{ -96.91352798409686, 32.83555912509139 }, { -96.91008395977508, 32.83845285132874 }},
+    {{ -96.91371598452355, 32.83558112509138 }, { -96.91027195934834, 32.83847485132872 }},
+    {{ -96.9140479861915, 32.83566712509135 }, { -96.91060395768008, 32.838560851328694 }},
+    {{ -96.9142739878983, 32.8357551250913 }, { -96.91082995597309, 32.83864885132865 }},
+    {{ -96.91437798960509, 32.835843125091266 }, { -96.91093395426604, 32.83873685132861 }},
+    {{ -96.91637897736683, 32.835212125091545 }, { -96.91293496650609, 32.83810585132889 }},
+    {{ -96.91623999410484, 32.836075125091156 }, { -96.91279594976567, 32.8389688513285 }},
+    {{ -96.91619399703357, 32.836226125091095 }, { -96.9127499468365, 32.83911985132844 }},
+    {{ -96.91610499895377, 32.83632512509105 }, { -96.91266094491604, 32.8392188513284 }},
+    {{ -96.91600600062179, 32.836411125091 }, { -96.91256194324774, 32.83930485132834 }},
+    {{ -96.91587500153341, 32.83645812509098 }, { -96.912430942336, 32.839351851328324 }},
+    {{ -96.91574600166918, 32.83646512509099 }, { -96.91230194220022, 32.83935885132834 }},
+    {{ -96.91564700114552, 32.83643812509099 }, { -96.912202942724, 32.83933185132834 }},
+    {{ -96.91552600003993, 32.83638112509103 }, { -96.91208194382972, 32.83927485132837 }},
+    {{ -96.91539999811975, 32.83628212509107 }, { -96.91195594575017, 32.839175851328406 }},
+    {{ -96.91511299327082, 32.83603212509119 }, { -96.91166895059978, 32.838925851328526 }},
+    {{ -96.91499999034212, 32.83588112509125 }, { -96.91155595352893, 32.838774851328594 }},
+    {{ -96.91497398859653, 32.835791125091305 }, { -96.91152995527474, 32.83868485132864 }},
+    {{ -96.91498398685096, 32.835701125091326 }, { -96.91153995702057, 32.838594851328665 }},
+    {{ -96.9150269854933, 32.83563112509135 }, { -96.91158295837842, 32.8385248513287 }},
+    {{ -96.91509198444597, 32.83557712509138 }, { -96.91164795942592, 32.83847085132873 }},
+    {{ -96.91520198405807, 32.8355571250914 }, { -96.91175795981388, 32.83845085132874 }},
+    {{ -96.91620498165308, 32.835433125091456 }, { -96.9127609622192, 32.8383268513288 }},
+    {{ -96.91763698353438, 32.83553012509141 }, { -96.91419296033762, 32.83842385132875 }},
+    {{ -96.91790498405807, 32.8355571250914 }, { -96.91446095981388, 32.83845085132874 }},
+    {{ -96.91814698479507, 32.83559512509137 }, { -96.91470295907675, 32.83848885132871 }},
+    {{ -96.91858398716128, 32.83571712509132 }, { -96.9151399567102, 32.83861085132867 }},
+    {{ -96.91690504414862, 32.83865512509 }, { -96.91346089971469, 32.84154885132734 }},
+    {{ -96.91687304079277, 32.838482125090074 }, { -96.91342890307102, 32.84137585132741 }},
+    {{ -96.91683503322767, 32.838092125090256 }, { -96.91339091063722, 32.840985851327595 }},
+    {{ -96.91673002224884, 32.837526125090506 }, { -96.91328592161763, 32.840419851327844 }},
+    {{ -96.91667101753538, 32.837283125090615 }, { -96.91322692633173, 32.84017685132796 }},
+    {{ -96.9166310128996, 32.83704412509072 }, { -96.9131869309682, 32.83993785132806 }},
+    {{ -96.91655600791474, 32.83678712509084 }, { -96.91311193595378, 32.83968085132818 }},
+    {{ -96.9164500940436, 32.84122712508884 }, { -96.91300584981255, 32.844120851326174 }},
+    {{ -96.91649409202596, 32.84112312508889 }, { -96.9130498518305, 32.84401685132623 }},
+    {{ -96.91659408634168, 32.840830125089006 }, { -96.91314985751559, 32.84372385132636 }},
+    {{ -96.91669607978447, 32.84049212508917 }, { -96.91325186407373, 32.843385851326516 }},
+    {{ -96.91673607410037, 32.8401991250893 }, { -96.91329186975865, 32.84309285132664 }},
+    {{ -96.91678706894014, 32.83993312508942 }, { -96.91334287491964, 32.84282685132677 }},
+    {{ -96.91683506137448, 32.8395431250896 }, { -96.91339088248637, 32.842436851326944 }},
+    {{ -96.91689704839683, 32.8388741250899 }, { -96.91345289546588, 32.84176785132724 }},
+    {{ -96.9169150388142, 32.838380125090126 }, { -96.91347090504988, 32.84127385132747 }},
+    {{ -96.91692602946458, 32.83789812509034 }, { -96.91348191440086, 32.84079185132768 }},
+    {{ -96.91697202364541, 32.83759812509048 }, { -96.91352792022083, 32.84049185132781 }},
+    {{ -96.9170470180979, 32.83731212509061 }, { -96.91360292576915, 32.84020585132795 }},
+    {{ -96.91720501237589, 32.83701712509073 }, { -96.91376093149196, 32.83991085132807 }},
+    {{ -96.91738000795353, 32.836789125090846 }, { -96.91393593591498, 32.83968285132819 }},
+    {{ -96.91762900227046, 32.836496125090974 }, { -96.91418494159886, 32.83938985132831 }},
+    {{ -96.91793199773183, 32.836262125091075 }, { -96.91448794613815, 32.839155851328414 }},
+    {{ -96.91808199585044, 32.83616512509112 }, { -96.9146379480198, 32.83905885132847 }},
+    {{ -96.91830999330962, 32.83603412509118 }, { -96.914865950561, 32.83892785132853 }},
+    {{ -96.91866999026453, 32.83587712509125 }, { -96.91522595360651, 32.8387708513286 }},
+    {{ -96.91903198762677, 32.83574112509132 }, { -96.91558795624465, 32.838634851328656 }},
+    {{ -96.9197479858812, 32.83565112509135 }, { -96.91630395799046, 32.8385448513287 }},
+    {{ -96.92056898514417, 32.83561312509138 }, { -96.91712495872758, 32.838506851328724 }},
+    {{ -96.92111298475629, 32.83559312509138 }, { -96.91766895911556, 32.838486851328724 }},
+    {{ -96.92156898417443, 32.83556312509139 }, { -96.9181249596975, 32.838456851328736 }},
+    {{ -96.92189598322406, 32.83551412509142 }, { -96.91845196064797, 32.83840785132876 }},
+    {{ -96.91632503611791, 32.838241125090185 }, { -96.91288090774655, 32.84113485132754 }},
+    {{ -96.91605706325616, 32.83964012508955 }, { -96.91261288060439, 32.8425338513269 }},
+    {{ -96.91582107895027, 32.84044912508918 }, { -96.91237686490803, 32.843342851326526 }},
+    {{ -96.91554509216175, 32.841130125088874 }, { -96.91210085169466, 32.84402385132622 }},
+    {{ -96.9154920940436, 32.84122712508884 }, { -96.91204784981255, 32.844120851326174 }},
+    {{ -96.91763698353438, 32.83553012509141 }, { -96.91419296033762, 32.83842385132875 }},
+    {{ -96.91782698479507, 32.83559512509137 }, { -96.91438295907676, 32.83848885132871 }},
+    {{ -96.91790498623033, 32.83566912509136 }, { -96.91446095764131, 32.83856285132869 }},
+    {{ -96.91793998716128, 32.83571712509132 }, { -96.9144959567102, 32.83861085132867 }},
+    {{ -96.91795398824742, 32.83577312509131 }, { -96.91450995562391, 32.83866685132865 }},
+    {{ -96.91794498995421, 32.83586112509127 }, { -96.91450095391689, 32.8387548513286 }},
+    {{ -96.91792399086579, 32.835908125091244 }, { -96.91447995300516, 32.83880185132858 }},
+    {{ -96.91772799476429, 32.83610912509115 }, { -96.9142839491061, 32.83900285132848 }},
+    {{ -96.91743599908953, 32.83633212509104 }, { -96.91399194478024, 32.839225851328386 }},
+    {{ -96.91731000027268, 32.83639312509102 }, { -96.91386594359693, 32.83928685132837 }},
+    {{ -96.91714100087395, 32.836424125091014 }, { -96.91369694299557, 32.839317851328346 }},
+    {{ -96.91701500079637, 32.83642012509102 }, { -96.91357094307315, 32.839313851328356 }},
+    {{ -96.91686200003993, 32.83638112509103 }, { -96.9134179438297, 32.83927485132837 }},
+    {{ -96.91678399899256, 32.836327125091046 }, { -96.91333994487724, 32.839220851328385 }},
+    {{ -96.91673599821672, 32.83628712509106 }, { -96.91329194565319, 32.83918085132841 }},
+    {{ -96.91664699588924, 32.83616712509113 }, { -96.91320294798099, 32.83906085132847 }},
+    {{ -96.91660999396908, 32.83606812509117 }, { -96.91316594990144, 32.838961851328506 }},
+    {{ -96.91655298974086, 32.83585012509127 }, { -96.91310895413027, 32.8387438513286 }},
+    {{ -96.91946491499829, 32.831996125093006 }, { -96.91602102888356, 32.834889851330345 }},
+    {{ -96.91948797531097, 32.8351061250916 }, { -96.9160439685622, 32.83799985132893 }},
+    {{ -96.9141210940436, 32.84122712508884 }, { -96.91067684981255, 32.844120851326174 }},
+    {{ -96.91320906880432, 32.83992612508941 }, { -96.90976487505543, 32.842819851326766 }},
+    {{ -96.9121220693087, 32.83995212508941 }, { -96.90867787455099, 32.84284585132676 }},
+    {{ -96.91244209338399, 32.84119312508886 }, { -96.90899785047226, 32.844086851326196 }},
+    {{ -96.9124390940436, 32.84122712508884 }, { -96.90899484981256, 32.844120851326174 }},
+    {{ -96.91330591499829, 32.831996125093006 }, { -96.90986202888357, 32.834889851330345 }},
+    {{ -96.9133029196717, 32.83223712509289 }, { -96.90985902420945, 32.835130851330234 }},
+    {{ -96.91328095044784, 32.83382412509218 }, { -96.90983699342891, 32.83671785132952 }},
+    {{ -96.9132759727315, 32.834973125091665 }, { -96.90983197114207, 32.837866851329 }},
+    {{ -96.92212491499828, 32.831996125093006 }, { -96.91868102888355, 32.834889851330345 }},
+    {{ -96.92211892374401, 32.8324471250928 }, { -96.91867502013655, 32.83534085133014 }},
+    {{ -96.91212191924508, 32.8322151250929 }, { -96.90867802463615, 32.83510885133024 }},
+    {{ -96.9133029196717, 32.83223712509289 }, { -96.90985902420945, 32.835130851330234 }},
+    {{ -96.91649693584488, 32.833071125092516 }, { -96.91305300803398, 32.83596485132987 }},
+    {{ -96.9162339459292, 32.833591125092276 }, { -96.91278999794821, 32.83648485132962 }},
+    {{ -96.91604895366716, 32.8339901250921 }, { -96.91260499020915, 32.836883851329446 }},
+    {{ -96.9157379672235, 32.8346891250918 }, { -96.91229397665084, 32.83758285132914 }},
+    {{ -96.91569496865867, 32.834763125091754 }, { -96.91225097521547, 32.83765685132909 }},
+    {{ -96.91562797001627, 32.83483312509173 }, { -96.91218397385767, 32.83772685132906 }},
+    {{ -96.91549097154844, 32.83491212509169 }, { -96.9120469723253, 32.83780585132903 }},
+    {{ -96.9153969720333, 32.83493712509168 }, { -96.91195297184036, 32.837830851329024 }},
+    {{ -96.91492497321636, 32.834998125091644 }, { -96.91148097065712, 32.83789185132899 }},
+    {{ -96.91212198846075, 32.835784125091294 }, { -96.90867795541052, 32.83867785132863 }},
+    {{ -96.9124169878983, 32.8357551250913 }, { -96.90897295597308, 32.83864885132865 }},
+    {{ -96.91274698751039, 32.835735125091325 }, { -96.90930295636103, 32.83862885132866 }},
+    {{ -96.91307698723887, 32.835721125091325 }, { -96.90963295663262, 32.838614851328664 }},
+    {{ -96.91366998723886, 32.835721125091325 }, { -96.9102259566326, 32.838614851328664 }},
+    {{ -96.91411298828622, 32.835775125091295 }, { -96.91066895558512, 32.83866885132864 }},
+    {{ -96.91437798960509, 32.835843125091266 }, { -96.91093395426604, 32.83873685132861 }},
+    {{ -96.91479399406605, 32.836073125091154 }, { -96.91134994980445, 32.8389668513285 }},
+    {{ -96.91791100686734, 32.83673312509086 }, { -96.91446693700134, 32.83962685132821 }},
+    {{ -96.91983899055546, 32.83589212509124 }, { -96.91639495331553, 32.838785851328595 }},
+    {{ -96.9198870768939, 32.84034312508924 }, { -96.9164428669647, 32.84323685132657 }},
+    {{ -96.91905106133568, 32.8395411250896 }, { -96.91560688252517, 32.84243485132695 }},
+    {{ -96.91874205582643, 32.83925712508973 }, { -96.91529788803521, 32.84215085132708 }},
+    {{ -96.91853305355679, 32.839140125089784 }, { -96.91508889030517, 32.84203385132712 }},
+    {{ -96.9183830522377, 32.83907212508981 }, { -96.91493889162446, 32.84196585132715 }},
+    {{ -96.9180900509768, 32.83900712508984 }, { -96.91464589288553, 32.84190085132718 }},
+    {{ -96.91788605066641, 32.83899112508985 }, { -96.91444189319596, 32.84188485132719 }},
+    {{ -96.9169850510544, 32.83901112508983 }, { -96.91354089280793, 32.84190485132717 }},
+    {{ -96.91585905289725, 32.83910612508979 }, { -96.91241489096481, 32.84199985132713 }},
+    {{ -96.91603805293605, 32.839108125089794 }, { -96.91259389092602, 32.84200185132714 }},
+    {{ -96.915872050938, 32.83900512508984 }, { -96.91242789292434, 32.84189885132718 }},
+    {{ -96.91577606509908, 32.83973512508951 }, { -96.91233187876121, 32.84262885132685 }},
+    {{ -96.91569807266481, 32.84012512508934 }, { -96.91225387119442, 32.843018851326676 }},
+    {{ -96.91556408191846, 32.84060212508912 }, { -96.91211986193943, 32.84349585132646 }},
+    {{ -96.9154130889995, 32.84096712508895 }, { -96.91196885485739, 32.8438608513263 }},
+    {{ -96.9152910940436, 32.84122712508884 }, { -96.91184684981255, 32.844120851326174 }},
+    {{ -96.9166410940436, 32.84122712508884 }, { -96.91319684981255, 32.844120851326174 }},
+    {{ -96.9166420939854, 32.841224125088836 }, { -96.91319784987074, 32.844117851326175 }},
+    {{ -96.91682208428526, 32.84072412508907 }, { -96.9133778595723, 32.84361785132641 }},
+    {{ -96.91696607165603, 32.84007312508936 }, { -96.91352187220332, 32.8429668513267 }},
+    {{ -96.91704406116109, 32.839532125089605 }, { -96.91359988269978, 32.84242585132694 }},
+    {{ -96.91709805320761, 32.83912212508979 }, { -96.91365389065439, 32.84201585132713 }},
+    {{ -96.91710605097681, 32.83900712508984 }, { -96.91366189288554, 32.84190085132718 }},
+    {{ -96.91719591499829, 32.831996125093006 }, { -96.91375202888356, 32.834889851330345 }},
+    {{ -96.91710091928385, 32.83221712509291 }, { -96.91365702459737, 32.83511085133024 }},
+    {{ -96.91703592137819, 32.832325125092865 }, { -96.91359202250273, 32.835218851330204 }},
+    {{ -96.91698292287138, 32.83240212509282 }, { -96.91353902100933, 32.83529585133016 }},
+    {{ -96.91680292740914, 32.832636125092705 }, { -96.91335901647092, 32.83552985133006 }},
+    {{ -96.91649693584488, 32.833071125092516 }, { -96.91305300803398, 32.83596485132987 }},
+    {{ -96.91479399406605, 32.836073125091154 }, { -96.91134994980445, 32.8389668513285 }},
+    {{ -96.91491699577286, 32.836161125091124 }, { -96.9114729480974, 32.83905485132847 }},
+    {{ -96.91539700341482, 32.836555125090946 }, { -96.91195294045433, 32.83944885132829 }},
+    {{ -96.91541600358939, 32.83656412509095 }, { -96.91197194027974, 32.839457851328284 }},
+    {{ -96.91568200805051, 32.83679412509083 }, { -96.91223793581798, 32.83968785132818 }},
+    {{ -96.9157760100677, 32.83689812509079 }, { -96.91233193380047, 32.83979185132812 }},
+    {{ -96.91588301320994, 32.837060125090716 }, { -96.91243893065779, 32.83995385132806 }},
+    {{ -96.91597701722505, 32.83726712509063 }, { -96.91253292664213, 32.840160851327965 }},
+    {{ -96.9160140206389, 32.83744312509054 }, { -96.91256992322779, 32.84033685132788 }},
+    {{ -96.91604102399457, 32.83761612509046 }, { -96.91259691987165, 32.840509851327816 }},
+    {{ -96.91590404407103, 32.83865112509 }, { -96.9124598997923, 32.84154485132734 }},
+    {{ -96.915872050938, 32.83900512508984 }, { -96.91242789292434, 32.84189885132718 }},
+    {{ -96.91912797538855, 32.835110125091596 }, { -96.91568396848461, 32.838003851328935 }},
+    {{ -96.91760197461278, 32.83507012509161 }, { -96.91415796926053, 32.837963851328965 }},
+    {{ -96.91749997430246, 32.83505412509162 }, { -96.91405596957087, 32.83794785132897 }},
+    {{ -96.91744897391457, 32.835034125091624 }, { -96.91400496995882, 32.83792785132896 }},
+    {{ -96.91741197346849, 32.83501112509164 }, { -96.91396797040495, 32.837904851328986 }},
+    {{ -96.91736597277028, 32.83497512509165 }, { -96.91392197110326, 32.83786885132899 }},
+    {{ -96.91733097199452, 32.83493512509168 }, { -96.91388697187915, 32.83782885132902 }},
+    {{ -96.91730997133509, 32.8349011250917 }, { -96.91386597253866, 32.837794851329036 }},
+    {{ -96.91729397050113, 32.834858125091706 }, { -96.91384997337273, 32.83775185132905 }},
+    {{ -96.91728596914353, 32.83478812509174 }, { -96.91384197473054, 32.83768185132909 }},
+    {{ -96.9172859675726, 32.83470712509179 }, { -96.91384197630171, 32.837600851329114 }},
+    {{ -96.91738995428774, 32.83402212509209 }, { -96.91394598958846, 32.83691585132943 }},
+    {{ -96.91747594183725, 32.833380125092376 }, { -96.91403200204074, 32.83627385132972 }},
+    {{ -96.91750293916103, 32.83324212509243 }, { -96.91405900471734, 32.83613585132978 }},
+    {{ -96.9175569365818, 32.833109125092506 }, { -96.91411300729696, 32.83600285132985 }},
+    {{ -96.9177739272346, 32.83262712509272 }, { -96.91433001664547, 32.83552085133007 }},
+    {{ -96.91800491499829, 32.831996125093006 }, { -96.91456102888357, 32.834889851330345 }},
+    {{ -96.91710605097681, 32.83900712508984 }, { -96.91366189288554, 32.84190085132718 }},
+    {{ -96.91713003817407, 32.83834712509014 }, { -96.9136859056901, 32.84124085132747 }},
+    {{ -96.91713302946458, 32.83789812509034 }, { -96.91368891440086, 32.84079185132768 }},
+    {{ -96.91718102409155, 32.83762112509046 }, { -96.91373691977464, 32.840514851327804 }},
+    {{ -96.91726201976603, 32.83739812509056 }, { -96.91381792410078, 32.8402918513279 }},
+    {{ -96.91735801670134, 32.83724012509064 }, { -96.91391392716592, 32.840133851327984 }},
+    {{ -96.91748701363667, 32.83708212509072 }, { -96.91404293023102, 32.83997585132805 }},
+    {{ -96.91766701031987, 32.836911125090786 }, { -96.91422293354829, 32.83980485132813 }},
+    {{ -96.91791100686734, 32.83673312509086 }, { -96.91446693700134, 32.83962685132821 }},
+    {{ -96.9211429870643, 32.83571212509132 }, { -96.91769895680719, 32.838605851328666 }},
+    {{ -96.92127898816983, 32.83576912509129 }, { -96.9178349557015, 32.83866285132864 }},
+    {{ -96.92141898956629, 32.83584112509127 }, { -96.91797495430484, 32.83873485132861 }},
+    {{ -96.92153399173858, 32.83595312509122 }, { -96.91808995213223, 32.83884685132857 }},
+    {{ -96.92159599327083, 32.83603212509119 }, { -96.91815195059978, 32.838925851328526 }},
+    {{ -96.92189401031986, 32.836911125090786 }, { -96.91844993354829, 32.83980485132813 }},
+    {{ -96.92201701976603, 32.83739812509056 }, { -96.91857292410077, 32.8402918513279 }},
+    {{ -96.92205502409155, 32.83762112509046 }, { -96.91861091977464, 32.840514851327804 }},
+    {{ -96.92204903095816, 32.83797512509031 }, { -96.91860491290703, 32.84086885132764 }},
+    {{ -96.92194503724296, 32.83829912509015 }, { -96.91850090662132, 32.84119285132749 }},
+    {{ -96.92179404306233, 32.83859912509002 }, { -96.91834990080113, 32.84149285132736 }},
+    {{ -96.9216200475239, 32.83882912508992 }, { -96.91817589633894, 32.84172285132727 }},
+    {{ -96.92153404905635, 32.83890812508988 }, { -96.91808989480624, 32.84180185132723 }},
+    {{ -96.92114805516688, 32.839223125089745 }, { -96.91770388869487, 32.842116851327084 }},
+    {{ -96.91973407553594, 32.84027312508926 }, { -96.91628986832288, 32.84316685132661 }},
+    {{ -96.91925208232587, 32.8406231250891 }, { -96.91580786153199, 32.84351685132645 }},
+    {{ -96.91909608477026, 32.84074912508905 }, { -96.91565185908723, 32.8436428513264 }},
+    {{ -96.9184490940436, 32.84122712508884 }, { -96.91500484981255, 32.844120851326174 }},
+    {{ -96.91870309404361, 32.84122712508884 }, { -96.91525884981256, 32.844120851326174 }},
+    {{ -96.91880109264676, 32.841155125088875 }, { -96.9153568512096, 32.84404885132621 }},
+    {{ -96.91920908661328, 32.84084412508902 }, { -96.91576485724394, 32.84373785132635 }},
+    {{ -96.91983607759231, 32.840379125089214 }, { -96.91639186626621, 32.84327285132656 }},
+    {{ -96.92170605097681, 32.83900712508984 }, { -96.91826189288554, 32.84190085132718 }},
+    {{ -96.92195804668978, 32.83878612508993 }, { -96.91851389717318, 32.84167985132728 }},
+    {{ -96.9221510414911, 32.838518125090054 }, { -96.91870690237259, 32.84141185132741 }},
+    {{ -96.92223403860082, 32.83836912509012 }, { -96.91878990526328, 32.841262851327464 }},
+    {{ -96.92231203357683, 32.838110125090246 }, { -96.918867910288, 32.841003851327585 }},
+    {{ -96.92233402802918, 32.83782412509037 }, { -96.91888991583646, 32.84071785132771 }},
+    {{ -96.92232602628341, 32.837734125090414 }, { -96.91888191758245, 32.84062785132776 }},
+    {{ -96.92229602360662, 32.83759612509048 }, { -96.91885192025964, 32.84048985132782 }},
+    {{ -96.92213801443192, 32.83712312509069 }, { -96.91869392943565, 32.84001685132803 }},
+    {{ -96.92208701094057, 32.83694312509076 }, { -96.91864293292753, 32.83983685132811 }},
+    {{ -96.92206300843843, 32.83681412509083 }, { -96.91861893543, 32.83970785132817 }},
+    {{ -96.92202200568417, 32.836672125090885 }, { -96.91857793818467, 32.83956585132823 }},
+    {{ -96.92200400227046, 32.836496125090974 }, { -96.91855994159886, 32.83938985132831 }},
+    {{ -96.92199599852705, 32.836303125091064 }, { -96.9185519453428, 32.8391968513284 }},
+    {{ -96.92201699567589, 32.83615612509112 }, { -96.91857294819438, 32.83904985132846 }},
+    {{ -96.92204099437637, 32.836089125091156 }, { -96.91859694949407, 32.8389828513285 }},
+    {{ -96.92211899187434, 32.83596012509121 }, { -96.91867495199645, 32.83885385132855 }},
+    {{ -96.9222369895663, 32.83584112509127 }, { -96.91879295430485, 32.83873485132861 }},
+    {{ -96.92232298838319, 32.8357801250913 }, { -96.91887895548814, 32.83867385132864 }},
+    {{ -96.92244898727766, 32.83572312509131 }, { -96.91900495659381, 32.83861685132866 }},
+    {{ -96.91613197587343, 32.83513512509158 }, { -96.9126879679997, 32.838028851328936 }},
+    {{ -96.91590997566009, 32.8351241250916 }, { -96.91246596821304, 32.83801785132894 }},
+    {{ -96.91492497321636, 32.834998125091644 }, { -96.91148097065712, 32.83789185132899 }},
+    {{ -96.9160460509768, 32.83900712508984 }, { -96.91260189288553, 32.84190085132718 }},
+    {{ -96.915872050938, 32.83900512508984 }, { -96.91242789292434, 32.84189885132718 }},
+    {{ -96.92310897612555, 32.83514812509159 }, { -96.91966496774752, 32.838041851328924 }},
+    {{ -96.92253697610617, 32.83514712509158 }, { -96.91909296776691, 32.83804085132892 }},
+    {{ -96.91948797531097, 32.8351061250916 }, { -96.9160439685622, 32.83799985132893 }},
+    {{ -96.91912797538855, 32.835110125091596 }, { -96.91568396848461, 32.838003851328935 }},
+    {{ -96.91757297662981, 32.83517412509158 }, { -96.91412896724319, 32.838067851328915 }},
+    {{ -96.91718097662981, 32.83517412509158 }, { -96.91373696724318, 32.838067851328915 }},
+    {{ -96.91685097635828, 32.835160125091576 }, { -96.91340696751473, 32.838053851328915 }},
+    {{ -96.91983899055546, 32.83589212509124 }, { -96.91639495331553, 32.838785851328595 }},
+    {{ -96.92004598886807, 32.83580512509128 }, { -96.91660195500317, 32.838698851328616 }},
+    {{ -96.92030798758799, 32.835739125091315 }, { -96.91686395628346, 32.83863285132866 }},
+    {{ -96.9205659871031, 32.83571412509132 }, { -96.91712195676841, 32.83860785132867 }},
+    {{ -96.9211429870643, 32.83571212509132 }, { -96.91769895680719, 32.838605851328666 }},
+    {{ -96.92244898727766, 32.83572312509131 }, { -96.91900495659381, 32.83861685132866 }},
+    {{ -96.92310898727766, 32.83572312509131 }, { -96.9196649565938, 32.83861685132866 }},
+    {{ -96.91492497321636, 32.834998125091644 }, { -96.91148097065712, 32.83789185132899 }},
+    {{ -96.9148639730806, 32.83499112509165 }, { -96.9114199707929, 32.83788485132899 }},
+    {{ -96.9147209730806, 32.83499112509165 }, { -96.91127697079291, 32.83788485132899 }},
+    {{ -96.91449597286727, 32.834980125091654 }, { -96.91105197100629, 32.837873851329 }},
+    {{ -96.91429497298361, 32.834986125091646 }, { -96.9108509708899, 32.83787985132899 }},
+    {{ -96.9132759727315, 32.834973125091665 }, { -96.90983197114207, 32.837866851329 }},
+    {{ -96.91212197265392, 32.83496912509166 }, { -96.90867797121963, 32.83786285132901 }},
+    {{ -96.91697505311063, 32.839117125089786 }, { -96.9135308907514, 32.842010851327124 }},
+    {{ -96.91709805320761, 32.83912212508979 }, { -96.91365389065439, 32.84201585132713 }},
+    {{ -96.91753805307184, 32.83911512508979 }, { -96.9140938907902, 32.84200885132714 }},
+    {{ -96.91791905316883, 32.83912012508979 }, { -96.91447489069319, 32.842013851327124 }},
+    {{ -96.91820005377018, 32.83915112508977 }, { -96.91475589009175, 32.842044851327124 }},
+    {{ -96.91834505460432, 32.839194125089755 }, { -96.91490088925751, 32.84208785132709 }},
+    {{ -96.91847905578763, 32.83925512508973 }, { -96.91503488807402, 32.842148851327075 }},
+    {{ -96.9186350575723, 32.83934712508969 }, { -96.91519088628907, 32.84224085132703 }},
+    {{ -96.9190480646141, 32.83971012508952 }, { -96.91560387924628, 32.84260385132687 }},
+    {{ -96.91917406684502, 32.83982512508947 }, { -96.91572987701505, 32.8427188513268 }},
+    {{ -96.91967807633132, 32.84031412508924 }, { -96.91623386752738, 32.843207851326596 }},
+    {{ -96.91978307838768, 32.8404201250892 }, { -96.9163388654707, 32.84331385132655 }},
+    {{ -96.9162220940436, 32.84122712508884 }, { -96.91277784981256, 32.844120851326174 }},
+    {{ -96.91626909132755, 32.841087125088904 }, { -96.912824852529, 32.84398085132624 }},
+    {{ -96.91643008040526, 32.84052412508915 }, { -96.91298586345285, 32.84341785132649 }},
+    {{ -96.91652407074426, 32.84002612508938 }, { -96.91307987311522, 32.84291985132673 }},
+    {{ -96.91658006308158, 32.83963112508957 }, { -96.91313588077902, 32.8425248513269 }},
+    {{ -96.91660405656359, 32.839295125089706 }, { -96.91315988729797, 32.842188851327045 }},
+    {{ -96.9166290465152, 32.83877712508994 }, { -96.91318489734778, 32.84167085132729 }},
+    {{ -96.91663703646707, 32.83825912509018 }, { -96.91319290739735, 32.84115285132752 }},
+    {{ -96.91660702440191, 32.83763712509046 }, { -96.91316291946426, 32.840530851327806 }},
+    {{ -96.9165480055096, 32.83666312509089 }, { -96.91310393835924, 32.83955685132825 }},
+    {{ -96.91655298974086, 32.83585012509127 }, { -96.91310895413027, 32.8387438513286 }},
+    {{ -96.91670898176945, 32.83543912509145 }, { -96.91326496210282, 32.838332851328786 }},
+    {{ -96.91681398182763, 32.83544212509144 }, { -96.91336996204461, 32.83833585132879 }},
+    {{ -96.91624797938387, 32.83531612509151 }, { -96.91280396448872, 32.83820985132885 }},
+    {{ -96.91587697928689, 32.83531112509151 }, { -96.9124329645857, 32.83820485132886 }},
+    {{ -96.9121219792869, 32.83531112509151 }, { -96.9086779645857, 32.83820485132886 }},
+    {{ -96.92310898035362, 32.83536612509148 }, { -96.91966496351884, 32.83825985132882 }},
+    {{ -96.9205469800239, 32.83534912509149 }, { -96.9171029638486, 32.838242851328836 }},
+    {{ -96.91807997959722, 32.8353271250915 }, { -96.91463596427536, 32.83822085132884 }},
+    {{ -96.91672497946146, 32.83532012509149 }, { -96.91328096441114, 32.838213851328845 }},
+    {{ -96.91655298974086, 32.83585012509127 }, { -96.91310895413027, 32.8387438513286 }},
+    {{ -96.91659397744439, 32.835216125091556 }, { -96.91314996642849, 32.838109851328895 }},
+    {{ -96.91675496210344, 32.834425125091904 }, { -96.91331098177162, 32.83731885132925 }},
+    {{ -96.91686195411319, 32.8340131250921 }, { -96.91341798976302, 32.83690685132943 }},
+    {{ -96.91694794930363, 32.83376512509221 }, { -96.9135039945733, 32.836658851329545 }},
+    {{ -96.91757491998197, 32.83225312509288 }, { -96.91413102389916, 32.83514685133023 }},
+    {{ -96.91767191499827, 32.831996125093006 }, { -96.91422802888354, 32.834889851330345 }},
+    {{ -96.91681398182763, 32.83544212509144 }, { -96.91336996204461, 32.83833585132879 }},
+    {{ -96.91811998186644, 32.835444125091456 }, { -96.91467596200583, 32.838337851328795 }},
+    {{ -96.92126898326285, 32.835516125091424 }, { -96.91782496060918, 32.83840985132876 }},
+    {{ -96.92304398304951, 32.835505125091416 }, { -96.91959996082257, 32.838398851328755 }},
+    {{ -96.92310898304952, 32.835505125091416 }, { -96.91966496082256, 32.838398851328755 }},
+    {{ -96.91212198413564, 32.835561125091395 }, { -96.90867795973627, 32.838454851328734 }},
+    {{ -96.91239298353439, 32.83553012509141 }, { -96.90894896033761, 32.83842385132875 }},
+    {{ -96.91282198283616, 32.83549412509143 }, { -96.90937796103594, 32.83838785132877 }},
+    {{ -96.91326498252585, 32.835478125091434 }, { -96.9098209613463, 32.83837185132878 }},
+    {{ -96.9143589820022, 32.83545112509144 }, { -96.91091496187005, 32.838344851328785 }},
+    {{ -96.91522298176945, 32.83543912509145 }, { -96.91177896210282, 32.838332851328786 }},
+    {{ -96.91624998165308, 32.835433125091456 }, { -96.9128059622192, 32.8383268513288 }},
+    {{ -96.91749191499827, 32.831996125093006 }, { -96.91404802888356, 32.834889851330345 }},
+    {{ -96.91739291984624, 32.83224612509289 }, { -96.91394902403492, 32.835139851330226 }},
+    {{ -96.91706593584487, 32.833071125092516 }, { -96.91362200803398, 32.83596485132987 }},
+    {{ -96.91653196285982, 32.83446412509189 }, { -96.91308798101515, 32.83735785132922 }},
+    {{ -96.91647596704895, 32.83468012509178 }, { -96.91303197682542, 32.83757385132914 }},
+    {{ -96.91637897736683, 32.835212125091545 }, { -96.91293496650609, 32.83810585132889 }},
+    {{ -96.91633899406605, 32.836073125091154 }, { -96.91289494980445, 32.8389668513285 }},
+    {{ -96.91631701425736, 32.837114125090686 }, { -96.91287292961024, 32.84000785132803 }},
+    {{ -96.91632503611791, 32.838241125090185 }, { -96.91288090774655, 32.84113485132754 }},
+    {{ -96.91630905561304, 32.83924612508974 }, { -96.91286488824862, 32.84213985132708 }},
+    {{ -96.91623406566167, 32.8397641250895 }, { -96.91278987819858, 32.84265785132684 }},
+    {{ -96.91614307448836, 32.84021912508929 }, { -96.9126988693706, 32.84311285132663 }},
+    {{ -96.91600608477026, 32.84074912508905 }, { -96.91256185908722, 32.8436428513264 }},
+    {{ -96.91581909404358, 32.84122712508884 }, { -96.91237484981255, 32.844120851326174 }},
+    {{ -96.91603805293605, 32.839108125089794 }, { -96.91259389092602, 32.84200185132714 }},
+    {{ -96.91697505311063, 32.839117125089786 }, { -96.9135308907514, 32.842010851327124 }},
+    {{ -96.91858398716128, 32.83571712509132 }, { -96.9151399567102, 32.83861085132867 }},
+    {{ -96.91909898943054, 32.83583412509127 }, { -96.91565495444063, 32.83872785132861 }},
+    {{ -96.91685097635828, 32.835160125091576 }, { -96.91340696751473, 32.838053851328915 }},
+    {{ -96.91613197587343, 32.83513512509158 }, { -96.9126879679997, 32.838028851328936 }},
+    {{ -96.9169850510544, 32.83901112508983 }, { -96.91354089280793, 32.84190485132717 }},
+    {{ -96.9160460509768, 32.83900712508984 }, { -96.91260189288553, 32.84190085132718 }},
+    {{ -96.91624998165308, 32.835433125091456 }, { -96.9128059622192, 32.8383268513288 }},
+    {{ -96.91670898176945, 32.83543912509145 }, { -96.91326496210282, 32.838332851328786 }},
+    {{ -96.91672497946146, 32.83532012509149 }, { -96.91328096441114, 32.838213851328845 }},
+    {{ -96.91624797938387, 32.83531612509151 }, { -96.91280396448872, 32.83820985132885 }}
+};
diff --git a/third_party/geometry.hpp-0.9.2/.gitignore b/third_party/geometry.hpp-0.9.2/.gitignore
new file mode 100644
index 00000000000..204298f2389
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/.gitignore
@@ -0,0 +1,2 @@
+mason_packages
+test
diff --git a/third_party/geometry.hpp-0.9.2/.gitmodules b/third_party/geometry.hpp-0.9.2/.gitmodules
new file mode 100644
index 00000000000..44fba9a2fd4
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/.gitmodules
@@ -0,0 +1,3 @@
+[submodule ".mason"]
+	path = .mason
+	url = https://github.com/mapbox/mason.git
diff --git a/third_party/geometry.hpp-0.9.2/.travis.yml b/third_party/geometry.hpp-0.9.2/.travis.yml
new file mode 100644
index 00000000000..a567bdc5d8d
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/.travis.yml
@@ -0,0 +1,50 @@
+language: generic
+sudo: false
+
+matrix:
+  include:
+    - os: linux
+      env: CXX=g++-4.9
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'g++-4.9' ]
+    - os: linux
+      env: CXX=g++-5
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'g++-5' ]
+    - os: linux
+      env: CXX=g++-6
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'g++-6' ]
+    - os: linux
+      env: CXX=clang++-3.8
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'libstdc++-4.9-dev' ]
+      before_script:
+        - git submodule update --init
+        - .mason/mason install clang++ 3.8.1
+        - export PATH=$(.mason/mason prefix clang++ 3.8.1)/bin:$PATH
+    - os: linux
+      env: CXX=clang++-3.9
+      addons:
+        apt:
+          sources: [ 'ubuntu-toolchain-r-test' ]
+          packages: [ 'libstdc++-4.9-dev' ]
+      before_script:
+        - git submodule update --init
+        - .mason/mason install clang++ 3.9.1
+        - export PATH=$(.mason/mason prefix clang++ 3.9.1)/bin:$PATH
+    - os: osx
+      osx_image: xcode7.3
+
+cache: apt
+
+script:
+ - make test
diff --git a/third_party/geometry.hpp-0.9.2/LICENSE b/third_party/geometry.hpp-0.9.2/LICENSE
new file mode 100644
index 00000000000..8f6a86bd07e
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/LICENSE
@@ -0,0 +1,13 @@
+Copyright (c) 2016, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
\ No newline at end of file
diff --git a/third_party/geometry.hpp-0.9.2/Makefile b/third_party/geometry.hpp-0.9.2/Makefile
new file mode 100644
index 00000000000..ec95379ec22
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/Makefile
@@ -0,0 +1,19 @@
+CXXFLAGS += -I include -std=c++14 -DDEBUG -O0 -Wall -Wextra -Werror
+MASON ?= .mason/mason
+
+VARIANT = 1.1.4
+
+default: test
+
+$(MASON):
+	git submodule update --init
+
+mason_packages/headers/variant/$(VARIANT):
+	$(MASON) install variant $(VARIANT)
+
+test: tests/* include/mapbox/geometry/* mason_packages/headers/variant/$(VARIANT) Makefile
+	$(CXX) tests/*.cpp $(CXXFLAGS) `$(MASON) cflags variant $(VARIANT)` -o test
+	./test
+
+clean:
+	rm -f test
diff --git a/third_party/geometry.hpp-0.9.2/README.md b/third_party/geometry.hpp-0.9.2/README.md
new file mode 100644
index 00000000000..972614a3bc9
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/README.md
@@ -0,0 +1,83 @@
+# geometry.hpp
+
+Provides header-only, generic C++ interfaces for geometry types, geometry collections, and features.
+
+ - `mapbox::geometry::point`
+ - `mapbox::geometry::multi_point`
+ - `mapbox::geometry::line_string`
+ - `mapbox::geometry::multi_line_string`
+ - `mapbox::geometry::polygon`
+ - `mapbox::geometry::multi_polygon`
+ - `mapbox::geometry::geometry_collection`
+ - `mapbox::geometry::feature` (experimental)
+
+### Design
+
+These types are designed to be easy to parse and serialize to [GeoJSON](http://geojson.org/).
+
+They should also be a robust and high performance container for data processing and conversion.
+
+
+### Goals
+
+ - Header-only
+ - Fast compile
+ - c++11/c++14 compatibility
+ - No external dependencies for usage of core types (point, line_string, etc)
+ - Minimal dependencies for usage of enclosing `geometry` type (`mapbox::variant`)
+ - Easily [adaptable to `boost::geometry`](http://www.boost.org/doc/libs/1_56_0/libs/geometry/doc/html/geometry/examples/example__adapting_a_legacy_geometry_object_model.html)
+
+
+### Usage
+
+Using a single type directly (requires no external dependencies):
+
+```cpp
+#include <mapbox/geometry/point.hpp>
+#include <iostream>
+
+using mapbox::geometry::point;
+
+int main() {
+    point<double> pt(1.0,0.0);
+    std::clog << "x: " << pt.x << " y: " << pt.y << "\n";
+}
+```
+
+Creating a geometry collection (depends on https://github.com/mapbox/variant):
+
+```cpp
+#include <mapbox/geometry/geometry.hpp>
+#include <mapbox/variant.hpp>
+#include <iostream>
+
+using mapbox::geometry::geometry_collection;
+using mapbox::geometry::geometry;
+using mapbox::geometry::point;
+
+using point_type = point<double>;
+
+struct printer
+{
+    printer() {}
+
+    void operator()(point_type const& pt) const
+    {
+        std::clog << "x: " << pt.x << " y: " << pt.y << "\n";
+    }
+
+    template <typename T>
+    void operator()(T const& g) const
+    {
+        std::clog << "encountered non-point geometry\n";
+    }
+};
+
+int main() {
+    geometry_collection<double> gc;
+    gc.emplace_back(point_type(1.0,0.0));
+    geometry<double> const& geom = gc.at(0);
+    printer visitor;
+    mapbox::util::apply_visitor(visitor,geom);
+}
+```
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry.hpp
new file mode 100644
index 00000000000..e232453179e
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <mapbox/geometry/point.hpp>
+#include <mapbox/geometry/line_string.hpp>
+#include <mapbox/geometry/polygon.hpp>
+#include <mapbox/geometry/multi_point.hpp>
+#include <mapbox/geometry/multi_line_string.hpp>
+#include <mapbox/geometry/multi_polygon.hpp>
+#include <mapbox/geometry/geometry.hpp>
+#include <mapbox/geometry/feature.hpp>
+#include <mapbox/geometry/point_arithmetic.hpp>
+#include <mapbox/geometry/for_each_point.hpp>
+#include <mapbox/geometry/envelope.hpp>
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/box.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/box.hpp
new file mode 100644
index 00000000000..bf81b703ecd
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/box.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <mapbox/geometry/point.hpp>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T>
+struct box
+{
+    using point_type = point<T>;
+
+    constexpr box(point_type const& min_, point_type const& max_)
+        : min(min_), max(max_)
+    {}
+
+    point_type min;
+    point_type max;
+};
+
+template <typename T>
+constexpr bool operator==(box<T> const& lhs, box<T> const& rhs)
+{
+    return lhs.min == rhs.min && lhs.max == rhs.max;
+}
+
+template <typename T>
+constexpr bool operator!=(box<T> const& lhs, box<T> const& rhs)
+{
+    return lhs.min != rhs.min || lhs.max != rhs.max;
+}
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/envelope.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/envelope.hpp
new file mode 100644
index 00000000000..86035839858
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/envelope.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <mapbox/geometry/box.hpp>
+#include <mapbox/geometry/for_each_point.hpp>
+
+#include <limits>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename G, typename T = typename G::coordinate_type>
+box<T> envelope(G const& geometry)
+{
+    using limits = std::numeric_limits<T>;
+
+    T min_t = limits::has_infinity ? -limits::infinity() : limits::min();
+    T max_t = limits::has_infinity ?  limits::infinity() : limits::max();
+
+    point<T> min(max_t, max_t);
+    point<T> max(min_t, min_t);
+
+    for_each_point(geometry, [&] (point<T> const& point) {
+        if (min.x > point.x) min.x = point.x;
+        if (min.y > point.y) min.y = point.y;
+        if (max.x < point.x) max.x = point.x;
+        if (max.y < point.y) max.y = point.y;
+    });
+
+    return box<T>(min, max);
+}
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/feature.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/feature.hpp
new file mode 100644
index 00000000000..91354442eed
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/feature.hpp
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <mapbox/geometry/geometry.hpp>
+
+#include <mapbox/variant.hpp>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <mapbox/optional.hpp>
+
+namespace mapbox {
+namespace geometry {
+
+struct value;
+
+struct null_value_t
+{
+    constexpr null_value_t() {}
+    constexpr null_value_t(std::nullptr_t) {}
+};
+
+constexpr bool operator==(const null_value_t&, const null_value_t&) { return true; }
+constexpr bool operator!=(const null_value_t&, const null_value_t&) { return false; }
+constexpr bool operator<(const null_value_t&, const null_value_t&) { return false; }
+
+constexpr null_value_t null_value = null_value_t();
+
+// Multiple numeric types (uint64_t, int64_t, double) are present in order to support
+// the widest possible range of JSON numbers, which do not have a maximum range.
+// Implementations that produce `value`s should use that order for type preference,
+// using uint64_t for positive integers, int64_t for negative integers, and double
+// for non-integers and integers outside the range of 64 bits.
+using value_base = mapbox::util::variant<null_value_t, bool, uint64_t, int64_t, double, std::string,
+                                         mapbox::util::recursive_wrapper<std::vector<value>>,
+                                         mapbox::util::recursive_wrapper<std::unordered_map<std::string, value>>>;
+
+struct value : value_base
+{
+    using value_base::value_base;
+};
+
+using property_map = std::unordered_map<std::string, value>;
+
+// The same considerations and requirement for numeric types apply as for `value_base`.
+using identifier = mapbox::util::variant<uint64_t, int64_t, double, std::string>;
+
+template <class T>
+struct feature
+{
+    using coordinate_type = T;
+    using geometry_type = mapbox::geometry::geometry<T>; // Fully qualified to avoid GCC -fpermissive error.
+
+    geometry_type geometry;
+    property_map properties {};
+    mapbox::util::optional<identifier> id {};
+
+    // GCC 4.9 does not support C++14 aggregates with non-static data member
+    // initializers.
+    feature(geometry_type geometry_,
+            property_map properties_ = property_map {},
+            mapbox::util::optional<identifier> id_ = mapbox::util::optional<identifier> {})
+        : geometry(std::move(geometry_)),
+          properties(std::move(properties_)),
+          id(std::move(id_)) {}
+};
+
+template <class T>
+constexpr bool operator==(feature<T> const& lhs, feature<T> const& rhs)
+{
+    return lhs.id == rhs.id && lhs.geometry == rhs.geometry && lhs.properties == rhs.properties;
+}
+
+template <class T>
+constexpr bool operator!=(feature<T> const& lhs, feature<T> const& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template <class T, template <typename...> class Cont = std::vector>
+struct feature_collection : Cont<feature<T>>
+{
+    using coordinate_type = T;
+    using feature_type = feature<T>;
+    using container_type = Cont<feature_type>;
+    using container_type::container_type;
+};
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/for_each_point.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/for_each_point.hpp
new file mode 100644
index 00000000000..44d6e77bd0f
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/for_each_point.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <mapbox/geometry/geometry.hpp>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename Point, typename F>
+auto for_each_point(Point&& point, F&& f)
+    -> decltype(point.x, point.y, void())
+{
+    f(std::forward<Point>(point));
+}
+
+template <typename Container, typename F>
+auto for_each_point(Container&& container, F&& f)
+    -> decltype(container.begin(), container.end(), void());
+
+template <typename...Types, typename F>
+void for_each_point(mapbox::util::variant<Types...> const& geom, F&& f)
+{
+    mapbox::util::variant<Types...>::visit(geom, [&] (auto const& g) {
+        for_each_point(g, f);
+    });
+}
+
+template <typename...Types, typename F>
+void for_each_point(mapbox::util::variant<Types...> & geom, F&& f)
+{
+    mapbox::util::variant<Types...>::visit(geom, [&] (auto & g) {
+        for_each_point(g, f);
+    });
+}
+
+template <typename Container, typename F>
+auto for_each_point(Container&& container, F&& f)
+    -> decltype(container.begin(), container.end(), void())
+{
+    for (auto& e: container) {
+        for_each_point(e, f);
+    }
+}
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/geometry.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/geometry.hpp
new file mode 100644
index 00000000000..a9d072be7e2
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/geometry.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <mapbox/geometry/point.hpp>
+#include <mapbox/geometry/line_string.hpp>
+#include <mapbox/geometry/polygon.hpp>
+#include <mapbox/geometry/multi_point.hpp>
+#include <mapbox/geometry/multi_line_string.hpp>
+#include <mapbox/geometry/multi_polygon.hpp>
+
+#include <mapbox/variant.hpp>
+
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct geometry_collection;
+
+template <typename T>
+using geometry_base = mapbox::util::variant<point<T>,
+                                            line_string<T>,
+                                            polygon<T>,
+                                            multi_point<T>,
+                                            multi_line_string<T>,
+                                            multi_polygon<T>,
+                                            geometry_collection<T>>;
+
+template <typename T>
+struct geometry : geometry_base<T>
+{
+    using coordinate_type = T;
+    using geometry_base<T>::geometry_base;
+
+    /*
+     * The default constructor would create a point geometry with default-constructed coordinates;
+     * i.e. (0, 0). Since this is not particularly useful, and could hide bugs, it is disabled.
+     */
+    geometry() = delete;
+};
+
+template <typename T, template <typename...> class Cont>
+struct geometry_collection : Cont<geometry<T>>
+{
+    using coordinate_type = T;
+    using geometry_type = geometry<T>;
+    using container_type = Cont<geometry_type>;
+
+    geometry_collection() = default;
+    geometry_collection(geometry_collection const&) = default;
+    geometry_collection(geometry_collection &&) = default;
+    geometry_collection(std::initializer_list<geometry_type> && args)
+      : container_type(std::forward<std::initializer_list<geometry_type>>(args)) {};
+};
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/line_string.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/line_string.hpp
new file mode 100644
index 00000000000..6d811ce2210
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/line_string.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+// mapbox
+#include <mapbox/geometry/point.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct line_string : Cont<point<T> >
+{
+    using coordinate_type = T;
+    using point_type = point<T>;
+    using container_type = Cont<point_type>;
+    using container_type::container_type;
+};
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_line_string.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_line_string.hpp
new file mode 100644
index 00000000000..07a7a1d609d
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_line_string.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+// mapbox
+#include <mapbox/geometry/line_string.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct multi_line_string : Cont<line_string<T>>
+{
+    using coordinate_type = T;
+    using line_string_type = line_string<T>;
+    using container_type = Cont<line_string_type>;
+    using container_type::container_type;
+};
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_point.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_point.hpp
new file mode 100644
index 00000000000..a3c73cff912
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_point.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+// mapbox
+#include <mapbox/geometry/point.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct multi_point : Cont<point<T>>
+{
+    using coordinate_type = T;
+    using point_type = point<T>;
+    using container_type = Cont<point_type>;
+    using container_type::container_type;
+};
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_polygon.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_polygon.hpp
new file mode 100644
index 00000000000..ad230a04c85
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/multi_polygon.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+// mapbox
+#include <mapbox/geometry/polygon.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct multi_polygon : Cont<polygon<T>>
+{
+    using coordinate_type = T;
+    using polygon_type = polygon<T>;
+    using container_type = Cont<polygon_type>;
+    using container_type::container_type;
+};
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/point.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/point.hpp
new file mode 100644
index 00000000000..0cba4996e7f
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/point.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T>
+struct point
+{
+    using coordinate_type = T;
+
+    constexpr point()
+        : x(), y()
+    {}
+    constexpr point(T x_, T y_)
+        : x(x_), y(y_)
+    {}
+
+    T x;
+    T y;
+};
+
+template <typename T>
+constexpr bool operator==(point<T> const& lhs, point<T> const& rhs)
+{
+    return lhs.x == rhs.x && lhs.y == rhs.y;
+}
+
+template <typename T>
+constexpr bool operator!=(point<T> const& lhs, point<T> const& rhs)
+{
+    return !(lhs == rhs);
+}
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/point_arithmetic.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/point_arithmetic.hpp
new file mode 100644
index 00000000000..0c4c63278a5
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/point_arithmetic.hpp
@@ -0,0 +1,119 @@
+#pragma once
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T>
+point<T> operator+(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x + rhs.x, lhs.y + rhs.y);
+}
+
+template <typename T>
+point<T> operator+(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x + rhs, lhs.y + rhs);
+}
+
+template <typename T>
+point<T> operator-(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x - rhs.x, lhs.y - rhs.y);
+}
+
+template <typename T>
+point<T> operator-(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x - rhs, lhs.y - rhs);
+}
+
+template <typename T>
+point<T> operator*(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x * rhs.x, lhs.y * rhs.y);
+}
+
+template <typename T>
+point<T> operator*(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x * rhs, lhs.y * rhs);
+}
+
+template <typename T>
+point<T> operator/(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x / rhs.x, lhs.y / rhs.y);
+}
+
+template <typename T>
+point<T> operator/(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x / rhs, lhs.y / rhs);
+}
+
+template <typename T>
+point<T>& operator+=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x += rhs.x;
+    lhs.y += rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator+=(point<T>& lhs, T const& rhs)
+{
+    lhs.x += rhs;
+    lhs.y += rhs;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator-=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x -= rhs.x;
+    lhs.y -= rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator-=(point<T>& lhs, T const& rhs)
+{
+    lhs.x -= rhs;
+    lhs.y -= rhs;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator*=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x *= rhs.x;
+    lhs.y *= rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator*=(point<T>& lhs, T const& rhs)
+{
+    lhs.x *= rhs;
+    lhs.y *= rhs;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator/=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x /= rhs.x;
+    lhs.y /= rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator/=(point<T>& lhs, T const& rhs)
+{
+    lhs.x /= rhs;
+    lhs.y /= rhs;
+    return lhs;
+}
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/polygon.hpp b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/polygon.hpp
new file mode 100644
index 00000000000..99a66aa1259
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/include/mapbox/geometry/polygon.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+// mapbox
+#include <mapbox/geometry/point.hpp>
+
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct linear_ring : Cont<point<T>>
+{
+    using coordinate_type = T;
+    using point_type = point<T>;
+    using container_type = Cont<point_type>;
+    using container_type::container_type;
+};
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct polygon : Cont<linear_ring<T>>
+{
+    using coordinate_type = T;
+    using linear_ring_type = linear_ring<T>;
+    using container_type = Cont<linear_ring_type>;
+    using container_type::container_type;
+};
+
+} // namespace geometry
+} // namespace mapbox
diff --git a/third_party/geometry.hpp-0.9.2/tests/collection.cpp b/third_party/geometry.hpp-0.9.2/tests/collection.cpp
new file mode 100644
index 00000000000..a3105a4e883
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/tests/collection.cpp
@@ -0,0 +1,5 @@
+#include <mapbox/geometry.hpp>
+
+void test() {
+    mapbox::geometry::geometry_collection<double> gc;
+}
diff --git a/third_party/geometry.hpp-0.9.2/tests/test.cpp b/third_party/geometry.hpp-0.9.2/tests/test.cpp
new file mode 100644
index 00000000000..fcbde4fdcb5
--- /dev/null
+++ b/third_party/geometry.hpp-0.9.2/tests/test.cpp
@@ -0,0 +1,260 @@
+#include <mapbox/geometry.hpp>
+
+#include <cassert>
+
+using namespace mapbox::geometry;
+
+static void testPoint() {
+    point<double> p1;
+    assert(int(p1.x) == 0);
+    assert(int(p1.y) == 0);
+
+    point<uint32_t> p2(2, 3);
+    point<uint32_t> p3(4, 6);
+
+    assert((p2 + p3) == point<uint32_t>(6, 9));
+    assert((p2 + 1u) == point<uint32_t>(3, 4));
+    assert((p3 - p2) == point<uint32_t>(2, 3));
+    assert((p3 - 1u) == point<uint32_t>(3, 5));
+    assert((p3 * p2) == point<uint32_t>(8, 18));
+    assert((p2 * 2u) == point<uint32_t>(4, 6));
+    assert((p3 / p2) == point<uint32_t>(2, 2));
+    assert((p3 / 2u) == point<uint32_t>(2, 3));
+
+    { point<uint32_t> p(2, 3); assert((p += p3) == point<uint32_t>(6, 9)); }
+    { point<uint32_t> p(2, 3); assert((p += 1u) == point<uint32_t>(3, 4)); }
+    { point<uint32_t> p(4, 6); assert((p -= p2) == point<uint32_t>(2, 3)); }
+    { point<uint32_t> p(4, 6); assert((p -= 1u) == point<uint32_t>(3, 5)); }
+    { point<uint32_t> p(4, 6); assert((p *= p2) == point<uint32_t>(8, 18)); }
+    { point<uint32_t> p(2, 3); assert((p *= 2u) == point<uint32_t>(4, 6)); }
+    { point<uint32_t> p(4, 6); assert((p /= p2) == point<uint32_t>(2, 2)); }
+    { point<uint32_t> p(4, 6); assert((p /= 2u) == point<uint32_t>(2, 3)); }
+}
+
+static void testMultiPoint() {
+    multi_point<double> mp1;
+    assert(mp1.size() == 0);
+
+    multi_point<double> mp2(10);
+    assert(mp2.size() == 10);
+
+    assert(mp1 == mp1);
+    assert(!(mp1 != mp1));
+    assert(mp1 != mp2);
+}
+
+static void testLineString() {
+    line_string<double> ls1;
+    assert(ls1.size() == 0);
+
+    line_string<double> ls2(10);
+    assert(ls2.size() == 10);
+
+    assert(ls1 == ls1);
+    assert(!(ls1 != ls1));
+    assert(ls1 != ls2);
+}
+
+static void testMultiLineString() {
+    multi_line_string<double> mls1;
+    assert(mls1.size() == 0);
+
+    multi_line_string<double> mls2(10);
+    assert(mls2.size() == 10);
+
+    assert(mls1 == mls1);
+    assert(!(mls1 != mls1));
+    assert(mls1 != mls2);
+}
+
+static void testPolygon() {
+    polygon<double> pg1;
+    assert(pg1.size() == 0);
+
+    polygon<double> pg2({{{0, 1}}});
+    assert(pg2.size() == 1);
+    assert(pg2[0].size() == 1);
+    assert(pg2[0][0] == point<double>(0, 1));
+
+    assert(pg1 == pg1);
+    assert(!(pg1 != pg1));
+    assert(pg1 != pg2);
+}
+
+static void testMultiPolygon() {
+    multi_polygon<double> mpg1;
+    assert(mpg1.size() == 0);
+
+    multi_polygon<double> mpg2(10);
+    assert(mpg2.size() == 10);
+
+    assert(mpg1 == mpg1);
+    assert(!(mpg1 != mpg1));
+    assert(mpg1 != mpg2);
+}
+
+static void testGeometry() {
+    geometry<double> pg { point<double>() };
+    assert(pg.is<point<double>>());
+
+    geometry<double> lsg { line_string<double>() };
+    assert(lsg.is<line_string<double>>());
+
+    geometry<double> pgg { polygon<double>() };
+    assert(pgg.is<polygon<double>>());
+
+    geometry<double> mpg { multi_point<double>() };
+    assert(mpg.is<multi_point<double>>());
+
+    geometry<double> mlsg { multi_line_string<double>() };
+    assert(mlsg.is<multi_line_string<double>>());
+
+    geometry<double> mpgg { multi_polygon<double>() };
+    assert(mpgg.is<multi_polygon<double>>());
+
+    geometry<double> gcg { geometry_collection<double>() };
+    assert(gcg.is<geometry_collection<double>>());
+
+    assert(pg == pg);
+    assert(!(pg != pg));
+    assert(pg != lsg);
+}
+
+static void testGeometryCollection() {
+    geometry_collection<double> gc1;
+    assert(gc1.size() == 0);
+
+    assert(gc1 == gc1);
+    assert(!(gc1 != gc1));
+}
+
+static void testFeature() {
+    feature<double> pf { point<double>() };
+    assert(pf.geometry.is<point<double>>());
+    assert(pf.properties.size() == 0);
+
+    auto &p = pf.properties;
+
+    p["bool"] = true;
+    p["string"] = std::string("foo");
+    p["double"] = 2.5;
+    p["uint"] = uint64_t(10);
+    p["int"] = int64_t(-10);
+    p["null"] = null_value;
+
+    assert(p["bool"].is<bool>());
+    assert(p["bool"] == true);
+    assert(p["string"].is<std::string>());
+    assert(p["string"] == std::string("foo"));
+    assert(p["double"].is<double>());
+    assert(p["double"] == 2.5);
+    assert(p["uint"].is<uint64_t>());
+    assert(p["uint"] == uint64_t(10));
+    assert(p["int"].is<int64_t>());
+    assert(p["int"] == int64_t(-10));
+    assert(p["null"].is<null_value_t>());
+    assert(p["null"] == null_value);
+
+    p["null"] = null_value_t{};
+    assert(p["null"].is<null_value_t>());
+    assert(p["null"] == null_value);
+
+    assert(p == p);
+    assert(!(p != p));
+
+    assert(pf == pf);
+    assert(!(pf != pf));
+
+    assert(p.size() == 6);
+
+    feature<double> id1 { point<double>() };
+    id1.id = { uint64_t(1) };
+
+    feature<double> id2 { point<double>() };
+    id1.id = { uint64_t(2) };
+
+    assert(id1 == id1);
+    assert(id1 != id2);
+}
+
+static void testFeatureCollection() {
+    feature_collection<double> fc1;
+    assert(fc1.size() == 0);
+
+    assert(fc1 == fc1);
+    assert(!(fc1 != fc1));
+}
+
+struct point_counter {
+    std::size_t count = 0;
+    template <class Point>
+    void operator()(Point const&) { count++; };
+};
+
+static void testForEachPoint() {
+    auto count_points = [] (auto const& g) {
+        point_counter counter;
+        for_each_point(g, counter);
+        return counter.count;
+    };
+
+    assert(count_points(point<double>()) == 1);
+    assert(count_points(line_string<double>({{0, 1}, {2, 3}})) == 2);
+    assert(count_points(geometry<double>(polygon<double>({{{0, 1}, {2, 3}}}))) == 2);
+
+    auto point_negator = [] (point<double>& p) { p *= -1.0; };
+
+    point<double> p(1, 2);
+    for_each_point(p, point_negator);
+    assert(p == point<double>(-1, -2));
+
+    line_string<double> ls({{0, 1}, {2, 3}});
+    for_each_point(ls, point_negator);
+    assert(ls == line_string<double>({{0, -1}, {-2, -3}}));
+
+    geometry<double> g(polygon<double>({{{0, 1}, {2, 3}}}));
+    for_each_point(g, point_negator);
+    assert(g == geometry<double>(polygon<double>({{{0, -1}, {-2, -3}}})));
+
+    // Custom geometry type
+    using my_geometry = mapbox::util::variant<point<double>>;
+    assert(count_points(my_geometry(point<double>())) == 1);
+
+    // Custom point type
+    struct my_point {
+        int16_t x;
+        int16_t y;
+    };
+    assert(count_points(std::vector<my_point>({my_point{0, 1}})) == 1);
+    assert(count_points(mapbox::util::variant<my_point>(my_point{0, 1})) == 1);
+}
+
+static void testEnvelope() {
+    assert(envelope(point<double>(0, 0)) == box<double>({0, 0}, {0, 0}));
+    assert(envelope(line_string<double>({{0, 1}, {2, 3}})) == box<double>({0, 1}, {2, 3}));
+    assert(envelope(polygon<double>({{{0, 1}, {2, 3}}})) == box<double>({0, 1}, {2, 3}));
+
+    assert(envelope(multi_point<double>({{0, 0}})) == box<double>({0, 0}, {0, 0}));
+    assert(envelope(multi_line_string<double>({{{0, 1}, {2, 3}}})) == box<double>({0, 1}, {2, 3}));
+    assert(envelope(multi_polygon<double>({{{{0, 1}, {2, 3}}}})) == box<double>({0, 1}, {2, 3}));
+
+    assert(envelope(geometry<int>(point<int>(0, 0))) == box<int>({0, 0}, {0, 0}));
+    assert(envelope(geometry_collection<int>({point<int>(0, 0)})) == box<int>({0, 0}, {0, 0}));
+}
+
+int main() {
+    testPoint();
+    testMultiPoint();
+    testLineString();
+    testMultiLineString();
+    testPolygon();
+    testMultiPolygon();
+    testGeometry();
+    testGeometryCollection();
+    testFeature();
+    testFeatureCollection();
+
+    testForEachPoint();
+    testEnvelope();
+    return 0;
+}
diff --git a/third_party/libosmium/.clang-tidy b/third_party/libosmium/.clang-tidy
new file mode 100644
index 00000000000..9f3240b8700
--- /dev/null
+++ b/third_party/libosmium/.clang-tidy
@@ -0,0 +1,90 @@
+---
+Checks: '*,-android-cloexec-*,-cert-dcl21-cpp,-cert-err58-cpp,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-vararg,-fuchsia-*,-google-runtime-references,-hicpp-invalid-access-moved,-hicpp-no-array-decay,-hicpp-no-assembler,-hicpp-vararg,-misc-macro-parentheses,-misc-unused-parameters,-modernize-make-unique,-modernize-raw-string-literal,-readability-avoid-const-params-in-decls,-readability-implicit-bool-cast,-readability-implicit-bool-conversion'
+#
+#  For a list of check options, see:
+#  http://clang.llvm.org/extra/clang-tidy/checks/list.html
+#
+#  Disabled checks:
+#
+#  android-cloexec-*
+#    O_CLOEXEC isn't available on Windows making this non-portable.
+#
+#  cert-dcl21-cpp
+#    It is unclear whether this is still a good recommendation in modern C++.
+#
+#  cert-err58-cpp
+#    Used in several singelton factory functions. I don't know of a better
+#    way to do this and it is rather unlikely that this will be a problem.
+#
+#  cppcoreguidelines-owning-memory
+#    Don't want to add dependency on gsl library.
+#
+#  cppcoreguidelines-pro-bounds-array-to-pointer-decay
+#    Limited use and many false positives including for all asserts.
+#
+#  cppcoreguidelines-pro-bounds-constant-array-index
+#    Is needed for low-level code.
+#
+#  cppcoreguidelines-pro-bounds-pointer-arithmetic
+#    This is a low-level library, it needs to do pointer arithmetic.
+#
+#  cppcoreguidelines-pro-type-const-cast
+#    When you need it, you need it.
+#
+#  cppcoreguidelines-pro-type-reinterpret-cast
+#    This is a low-level library, it needs to do reinterpret-casts.
+#
+#  cppcoreguidelines-pro-type-static-cast-downcast
+#    This is needed and totally okay if we are sure about the types.
+#
+#  cppcoreguidelines-pro-type-vararg
+#    We need some of these functions at least and for some functions it isn't
+#    even clear that those are vararg functions.
+#
+#  fuchsia-*
+#    Much too strict.
+#
+#  google-runtime-references
+#    This is just a matter of preference, and we can't change the interfaces
+#    now anyways.
+#
+#  hicpp-invalid-access-moved
+#    Creates false positives.
+#
+#  hicpp-no-array-decay
+#    Alias for cppcoreguidelines-pro-bounds-array-to-pointer-decay.
+#
+#  hicpp-no-assembler
+#    Reports are from macros we don't have any control over.
+#
+#  hicpp-vararg
+#    Too strict, sometimes calling vararg functions is necessary.
+#
+#  misc-macro-parentheses
+#    False positive in the only place where it reports something and
+#    disabling locally doesn't work.
+#
+#  misc-unused-parameters
+#    Can't be fixed, because then Doxygen will complain. (In file
+#    include/osmium/area/problem_reporter.hpp).
+#
+#  modernize-make-unique
+#    This is a C++11 library and C++ doesn't have std::make_unique.
+#
+#  modernize-raw-string-literal
+#    Readability isn't that much better, arguably worse because of the new
+#    syntax.
+#
+#  readability-avoid-const-params-in-decls
+#    This is header only library, so the declaration and implementation are
+#    often the same and we want to have the const in implementations.
+#
+#  readability-implicit-bool-cast
+#    Old name for readability-implicit-bool-conversion.
+#
+#  readability-implicit-bool-conversion
+#    I don't think this makes the code more readable.
+#
+#WarningsAsErrors: '*'
+HeaderFilterRegex: '\/include\/osmium\/.*'
+...
diff --git a/third_party/libosmium/.gitmodules b/third_party/libosmium/.gitmodules
new file mode 100644
index 00000000000..b42b21d77cd
--- /dev/null
+++ b/third_party/libosmium/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "test/data-tests/osm-testdata"]
+	path = test/data-tests/osm-testdata
+	url = https://github.com/osmcode/osm-testdata
diff --git a/third_party/libosmium/.travis.yml b/third_party/libosmium/.travis.yml
index 33239630886..bc5615d9b8b 100644
--- a/third_party/libosmium/.travis.yml
+++ b/third_party/libosmium/.travis.yml
@@ -8,6 +8,10 @@ language: generic
 
 sudo: false
 
+dist: trusty
+
+#-----------------------------------------------------------------------------
+
 cache:
   directories:
     - $HOME/.ccache
@@ -18,176 +22,195 @@ env:
     - CCACHE_COMPRESS=1
     - CASHER_TIME_OUT=1000
 
+#-----------------------------------------------------------------------------
+
+# Save common build configurations as shortcuts, so we can reference them later.
+addons_shortcuts:
+  addons_clang35: &clang35
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-3.5']
+  addons_clang38: &clang38
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-3.8']
+  addons_clang39: &clang39
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-3.9']
+  addons_clang40: &clang40
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest', 'llvm-toolchain-trusty-4.0' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-4.0']
+  addons_clang50: &clang50
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest', 'llvm-toolchain-trusty-5.0' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-5.0', 'g++-6', 'gcc-6']
+  addons_gcc48: &gcc48
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-4.8', 'gcc-4.8' ]
+  addons_gcc49: &gcc49
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-4.9', 'gcc-4.9' ]
+  addons_gcc5: &gcc5
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-5', 'gcc-5' ]
+  addons_gcc6: &gcc6
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-6', 'gcc-6' ]
+
+#-----------------------------------------------------------------------------
+
 matrix:
   include:
 
     # 1/ Linux Clang Builds
     - os: linux
       compiler: linux-clang35-release
-      addons:
-        apt:
-          sources: ['llvm-toolchain-precise-3.5', 'ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['clang-3.5', 'cmake', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='clang++-3.5' BUILD_TYPE='Release'
+      env: CC='clang-3.5' CXX='clang++-3.5' BUILD_TYPE='Release'
+      addons: *clang35
 
     - os: linux
       compiler: linux-clang35-dev
-      addons:
-        apt:
-          sources: ['llvm-toolchain-precise-3.5', 'ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['clang-3.5', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='clang++-3.5' BUILD_TYPE='Dev'
+      env: CC='clang-3.5' CXX='clang++-3.5' BUILD_TYPE='Dev'
+      addons: *clang35
+
+    - os: linux
+      compiler: linux-clang38-release
+      env: CC='clang-3.8' CXX='clang++-3.8' BUILD_TYPE='Release'
+      addons: *clang38
 
+    - os: linux
+      compiler: linux-clang38-dev
+      env: CC='clang-3.8' CXX='clang++-3.8' BUILD_TYPE='Dev'
+      addons: *clang38
 
     - os: linux
-      compiler: linux-clang37-release
-      addons:
-        apt:
-          sources: ['llvm-toolchain-precise-3.7', 'ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['clang-3.7', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='clang++-3.7' BUILD_TYPE='Release'
+      compiler: linux-clang39-release
+      env: CC='clang-3.9' CXX='clang++-3.9' BUILD_TYPE='Release'
+      addons: *clang39
 
     - os: linux
-      compiler: linux-clang37-dev
-      addons:
-        apt:
-          sources: ['llvm-toolchain-precise-3.7', 'ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['clang-3.7', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='clang++-3.7' BUILD_TYPE='Dev'
+      compiler: linux-clang39-dev
+      env: CC='clang-3.9' CXX='clang++-3.9' BUILD_TYPE='Dev'
+      addons: *clang39
 
+    - os: linux
+      compiler: linux-clang40-release
+      env: CC='clang-4.0' CXX='clang++-4.0' BUILD_TYPE='Release'
+      addons: *clang40
 
     - os: linux
-      compiler: linux-clang38-release
-      addons:
-        apt:
-          sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['clang-3.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Release'
+      compiler: linux-clang40-dev
+      env: CC='clang-4.0' CXX='clang++-4.0' BUILD_TYPE='Dev'
+      addons: *clang40
 
     - os: linux
-      compiler: linux-clang38-dev
-      addons:
-        apt:
-          sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['clang-3.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Dev'
+      compiler: linux-clang50-release
+      env: CC='clang-5.0' CXX='clang++-5.0' BUILD_TYPE='Release'
+      addons: *clang50
 
+    - os: linux
+      compiler: linux-clang50-dev
+      env: CC='clang-5.0' CXX='clang++-5.0' BUILD_TYPE='Dev'
+      addons: *clang50
+
+# Disabled because it creates false-positives on the old travis systems
+#    - os: linux
+#      compiler: linux-clang50-debug
+#      env: CC='clang-5.0' CXX='clang++-5.0' BUILD_TYPE='Debug'
+#           CXXFLAGS="-fsanitize=address,undefined,integer -fno-sanitize-recover=all -fno-omit-frame-pointer"
+#           LDFLAGS="-fsanitize=address,undefined,integer"
+#      # LSAN doesn't work on container-based system
+#      sudo: required
+#      addons: *clang50
 
     # 2/ Linux GCC Builds
     - os: linux
       compiler: linux-gcc48-release
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-4.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-4.8' COMPILER_FLAGS='-Wno-return-type' BUILD_TYPE='Release'
+      env: CC='gcc-4.8' CXX='g++-4.8' BUILD_TYPE='Release'
+           CXXFLAGS='-Wno-return-type'
+      addons: *gcc48
 
     - os: linux
       compiler: linux-gcc48-dev
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-4.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-4.8' COMPILER_FLAGS='-Wno-return-type' BUILD_TYPE='Dev'
-
+      env: CC='gcc-4.8' CXX='g++-4.8' BUILD_TYPE='Dev'
+           CXXFLAGS='-Wno-return-type'
+      addons: *gcc48
 
     - os: linux
       compiler: linux-gcc49-release
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-4.9', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-4.9' BUILD_TYPE='Release'
+      env: CC='gcc-4.9' CXX='g++-4.9' BUILD_TYPE='Release'
+      addons: *gcc49
 
     - os: linux
       compiler: linux-gcc49-dev
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-4.9', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-4.9' BUILD_TYPE='Dev'
-
+      env: CC='gcc-4.9' CXX='g++-4.9' BUILD_TYPE='Dev'
+      addons: *gcc49
 
     - os: linux
       compiler: linux-gcc5-release
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-5', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-5' BUILD_TYPE='Release'
+      env: CC='gcc-5' CXX='g++-5' BUILD_TYPE='Release'
+      addons: *gcc5
 
     - os: linux
       compiler: linux-gcc5-dev
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-5', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-5' BUILD_TYPE='Dev'
-
+      env: CC='gcc-5' CXX='g++-5' BUILD_TYPE='Dev'
+      addons: *gcc5
 
     - os: linux
       compiler: linux-gcc6-release
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-6', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-6' BUILD_TYPE='Release'
+      env: CC='gcc-6' CXX='g++-6' BUILD_TYPE='Release'
+      addons: *gcc6
 
     - os: linux
       compiler: linux-gcc6-dev
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-6', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-6' BUILD_TYPE='Dev'
+      env: CC='gcc-6' CXX='g++-6' BUILD_TYPE='Dev'
+      addons: *gcc6
 
     - os: linux
       compiler: linux-gcc6-coverage
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test', 'boost-latest']
-          packages: ['g++-6', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin']
-      env: COMPILER='g++-6' BUILD_TYPE='Coverage'
-
+      env: CC='gcc-6' CXX='g++-6' BUILD_TYPE='Coverage'
+      addons: *gcc6
 
     # 3/ OSX Clang Builds
     - os: osx
       osx_image: xcode6.4
       compiler: xcode64-clang-release
-      env: COMPILER='clang++' BUILD_TYPE='Release'
+      env: CC='clang' CXX='clang++' BUILD_TYPE='Release'
 
     - os: osx
       osx_image: xcode6.4
       compiler: xcode64-clang-dev
-      env: COMPILER='clang++' BUILD_TYPE='Dev'
-
+      env: CC='clang' CXX='clang++' BUILD_TYPE='Dev'
 
     - os: osx
       osx_image: xcode7
       compiler: xcode7-clang-release
-      env: COMPILER='clang++' BUILD_TYPE='Release'
+      env: CC='clang' CXX='clang++' BUILD_TYPE='Release'
 
     - os: osx
       osx_image: xcode7
       compiler: xcode7-clang-dev
-      env: COMPILER='clang++' BUILD_TYPE='Dev'
-
+      env: CC='clang' CXX='clang++' BUILD_TYPE='Dev'
 
     - os: osx
       osx_image: xcode8.3
       compiler: xcode8-clang-release
-      env: COMPILER='clang++' BUILD_TYPE='Release'
+      env: CC='clang' CXX='clang++' BUILD_TYPE='Release'
 
     - os: osx
       osx_image: xcode8.3
       compiler: xcode8-clang-dev
-      env: COMPILER='clang++' BUILD_TYPE='Dev'
+      env: CC='clang' CXX='clang++' BUILD_TYPE='Dev'
 
 
 install:
-  - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
-  - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR}
-  - git clone --quiet --depth 1 https://github.com/osmcode/osm-testdata.git
+  - git clone --quiet --depth 1 https://github.com/mapbox/protozero.git ../protozero
   - |
     if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
       brew remove gdal
@@ -197,8 +220,9 @@ install:
 
 before_script:
   - cd ${TRAVIS_BUILD_DIR}
+  - git submodule update --init
   - mkdir build && cd build
-  - CXX=${COMPILER} CXXFLAGS=${COMPILER_FLAGS} cmake -LA .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_WITH_CCACHE=1 -DOSM_TESTDATA="${TRAVIS_BUILD_DIR}/deps/osm-testdata"
+  - cmake -LA .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_DATA_TESTS=ON -DBUILD_WITH_CCACHE=1
 
 script:
   - make VERBOSE=1 && ctest --output-on-failure
@@ -208,11 +232,12 @@ after_success:
     if [ "${BUILD_TYPE}" = "Coverage" ]; then
       curl -S -f https://codecov.io/bash -o codecov
       chmod +x codecov
-      gcov-${COMPILER#g++-} -p $(find test/CMakeFiles -name '*.o')
-      ./codecov -Z -c -F unit_tests
-      gcov-${COMPILER#g++-} -p $(find test/data-tests -name '*.o')
-      ./codecov -Z -c -F data_tests
-      gcov-${COMPILER#g++-} -p $(find examples -name '*.o')
-      ./codecov -Z -c -F examples
+      gcov-${CXX#g++-} -p $(find test/CMakeFiles -name '*.o')
+      ./codecov -Z -c -X gcov -F unit_tests
+      gcov-${CXX#g++-} -p $(find test/data-tests -name '*.o')
+      ./codecov -Z -c -X gcov -F data_tests
+      gcov-${CXX#g++-} -p $(find examples -name '*.o')
+      ./codecov -Z -c -X gcov -F examples
     fi
 
+#-----------------------------------------------------------------------------
diff --git a/third_party/libosmium/CHANGELOG.md b/third_party/libosmium/CHANGELOG.md
index 2493e0af8ae..fa838f50b5f 100644
--- a/third_party/libosmium/CHANGELOG.md
+++ b/third_party/libosmium/CHANGELOG.md
@@ -2,7 +2,7 @@
 # Change Log
 
 All notable changes to this project will be documented in this file.
-This project adheres to [Semantic Versioning](http://semver.org/).
+This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [unreleased] -
 
@@ -13,6 +13,90 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Fixed
 
 
+## [2.14.0] - 2018-03-31
+
+### Added
+
+* Add `ReaderWithProgressBar` class. This wraps an `osmium::io::Reader` and an
+  `osmium::ProgressBar` into a nice little package allowing easier use in the
+  common case.
+* Add polygon implementation for WKT and GeoJSON geometry factories. (Thanks
+  to Horace Williams.)
+* Various tests.
+
+### Changed
+
+* Add git submodule with `osm-testdata` repository. Before this the repository
+  had to be installed externally. Now a submodule update can be used to get the
+  correct version of the osm-testdata repository.
+* The XML file reader was rewritten to be more strict. Cases where it could
+  be tricked into failing badly were removed. There are now more tests for the
+  XML parser.
+* Replaced `strftime` by our own implementation. Uses a specialized
+  implementation for our use case instead the more general `strftime`.
+  Benchmarked this to be faster.
+* Changed the way IDs are parsed from strings. No asserts are used any more but
+  checks are done and an exception is thrown when IDs are out of range. This
+  also changes the way negative values are handled. The value `-1` is now
+  always accepted for all IDs and returned as `0`. This deprecates the
+  `string_to_user_id()` function, use `string_to_uid()` instead which returns a
+  different type.
+* It was always a bit confusing that some of the util classes and functions are
+  directly in the `osmium` namespace and some are in `osmium::util`. The
+  `osmium::util` namespace is now declared `inline`. which allows all util
+  classes and functions to be addressed directly in the `osmium` namespace
+  while keeping backwards compatibility.
+* An error is now thrown when the deprecated `pbf_add_metadata` file format
+  option is used. Use `add_metadata` instead.
+* Extended the `add_metadata` file format option. In addition to allowing the
+  values `true`, `yes`, `false`, and `no`, the new values `all` and `none`
+  are now recognized. The option can also be set to a list of attributes
+  separated by the `+` sign. Attributes are `version`, `timestamp`,
+  `changeset`, `uid`, and `user`. All output formats have been updated to
+  only output the specified attributes. This is based on the new
+  `osmium::metadata_options` class which stores information about what metadata
+  an `OSMObject` has or should have. (Thanks to Michael Reichert.)
+* The `<` (less than) operator on `OSMObject`s now ignores the case when
+  one or both of the timestamps on the objects are not set at all. This
+  allows better handling of OSM data files with reduced metadata.
+* Allow `version = -1` and `changeset = -1` in PBF input. This value is
+  sometimes used by other programs to denote "no value". Osmium uses the `0`
+  for this.
+* The example programs using the `getopt_long` function have been rewritten to
+  work without it. This makes using libosmium on Windows easier, where this
+  function is not available.
+* Removed the embedded protozero from repository. Like other dependencies you
+  have to install protozero first. If you check out the protozero repository
+  in the same directory where you checked out libosmium, libosmium's CMake
+  will find it.
+* Various code cleanups, fixing of include order, etc.
+* Remove need for `winsock2` library in Windows by using code from Protozero.
+  (Thanks alex85k.)
+* Add MSYS2 build to Appveyor and fixed some Windows compile issues. (Thanks
+  to alex85k.)
+* Use array instead of map to store input/output format creators.
+* Update included `catch.hpp` to version 1.12.1.
+
+### Fixed
+
+* Remove check for lost ways in multipolygon assembler. This rules out too many
+  valid multipolygons, more specifically more complex ones with touching inner
+  rings.
+* Use different macro magic for registering index maps. This allows the maps
+  to be used for several types at the same time.
+* Lots of code was rewritten to fix warnings reported by `clang-tidy` making
+  libosmium more robust.
+* Make ADL work for `begin()`/`end()` of `InputIterator<Reader>`.
+* Various fixes to make the code more robust, including an undefined behaviour
+  in the debug output format and a buffer overflow in the o5m parser.
+* Range checks in o5m parser throw exceptions now instead of triggering
+  assertions.
+* Better checking that PBF data is in range.
+* Check `read` and `write` system calls for `EINTR`.
+* Use tag and type from protozero to make PBF parser more robust.
+* Test `testdata-multipolygon` on Windows was using the wrong executable name.
+
+
 ## [2.13.1] - 2017-08-25
 
 ### Added
@@ -739,7 +823,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
   Doxygen (up to version 1.8.8). This version contains a workaround to fix
   this.
 
-[unreleased]: https://github.com/osmcode/libosmium/compare/v2.13.1...HEAD
+[unreleased]: https://github.com/osmcode/libosmium/compare/v2.14.0...HEAD
+[2.14.0]: https://github.com/osmcode/libosmium/compare/v2.13.1...v2.14.0
 [2.13.1]: https://github.com/osmcode/libosmium/compare/v2.13.0...v2.13.1
 [2.13.0]: https://github.com/osmcode/libosmium/compare/v2.12.2...v2.13.0
 [2.12.2]: https://github.com/osmcode/libosmium/compare/v2.12.1...v2.12.2
diff --git a/third_party/libosmium/CMakeLists.txt b/third_party/libosmium/CMakeLists.txt
index e27887590ae..a8409133f68 100644
--- a/third_party/libosmium/CMakeLists.txt
+++ b/third_party/libosmium/CMakeLists.txt
@@ -24,8 +24,8 @@ set(CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo;MinSizeRel;Dev;Cover
 project(libosmium)
 
 set(LIBOSMIUM_VERSION_MAJOR 2)
-set(LIBOSMIUM_VERSION_MINOR 13)
-set(LIBOSMIUM_VERSION_PATCH 1)
+set(LIBOSMIUM_VERSION_MINOR 14)
+set(LIBOSMIUM_VERSION_PATCH 0)
 
 set(LIBOSMIUM_VERSION
     "${LIBOSMIUM_VERSION_MAJOR}.${LIBOSMIUM_VERSION_MINOR}.${LIBOSMIUM_VERSION_PATCH}")
@@ -62,7 +62,6 @@ option(BUILD_BENCHMARKS "compile benchmark programs" ${dev_build})
 option(BUILD_DATA_TESTS "compile data tests, please run them with ctest" ${data_test_build})
 
 option(INSTALL_GDALCPP   "also install gdalcpp headers" OFF)
-option(INSTALL_PROTOZERO "also install protozero headers" OFF)
 option(INSTALL_UTFCPP    "also install utfcpp headers" OFF)
 
 option(WITH_PROFILING    "add flags needed for profiling" OFF)
@@ -173,17 +172,6 @@ set(_own_index)
 
 include_directories(SYSTEM ${OSMIUM_INCLUDE_DIRS})
 
-if(MSVC)
-    find_path(GETOPT_INCLUDE_DIR getopt.h)
-    find_library(GETOPT_LIBRARY NAMES wingetopt)
-    if(GETOPT_INCLUDE_DIR AND GETOPT_LIBRARY)
-        include_directories(SYSTEM ${GETOPT_INCLUDE_DIR})
-        list(APPEND OSMIUM_LIBRARIES ${GETOPT_LIBRARY})
-    else()
-        set(GETOPT_MISSING 1)
-    endif()
-endif()
-
 
 #-----------------------------------------------------------------------------
 #
@@ -402,21 +390,22 @@ if(BUILD_HEADERS)
     file(MAKE_DIRECTORY header_check)
 
     foreach(hpp ${ALL_HPPS})
-        string(REPLACE ".hpp" "" tmp ${hpp})
-        string(REPLACE "/" "__" libname ${tmp})
+        if(GDAL_FOUND OR NOT ((hpp STREQUAL "osmium/area/problem_reporter_ogr.hpp") OR (hpp STREQUAL "osmium/geom/ogr.hpp")))
+            string(REPLACE ".hpp" "" tmp ${hpp})
+            string(REPLACE "/" "__" libname ${tmp})
 
-        # Create a dummy .cpp file that includes the header file we want to
-        # check.
-        set(DUMMYCPP ${CMAKE_BINARY_DIR}/header_check/${libname}.cpp)
-        file(WRITE ${DUMMYCPP} "#include <${hpp}>\n")
+            # Create a dummy .cpp file that includes the header file we want to
+            # check.
+            set(DUMMYCPP ${CMAKE_BINARY_DIR}/header_check/${libname}.cpp)
+            file(WRITE ${DUMMYCPP} "#include <${hpp}> // IWYU pragma: keep\n")
 
-        # There is no way in CMake to just compile but not link a C++ file,
-        # so we pretend to build a library here.
-        add_library(${libname} STATIC ${DUMMYCPP} include/${hpp})
-
-        #### this is better but only supported from cmake 3.0:
-        ###add_library(${libname} OBJECT ${DUMMYCPP} include/${hpp})
+            # There is no way in CMake to just compile but not link a C++ file,
+            # so we pretend to build a library here.
+            add_library(${libname} STATIC ${DUMMYCPP} include/${hpp})
 
+            #### this is better but only supported from cmake 3.0:
+            ###add_library(${libname} OBJECT ${DUMMYCPP} include/${hpp})
+        endif()
     endforeach()
 endif()
 
@@ -427,10 +416,10 @@ endif()
 #
 #-----------------------------------------------------------------------------
 message(STATUS "Looking for clang-tidy")
-find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-3.9 clang-tidy-3.8 clang-tidy-3.7 clang-tidy-3.6 clang-tidy-3.5)
+find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-6.0 clang-tidy-5.0)
 
 if(CLANG_TIDY)
-    message(STATUS "Looking for clang-tidy - found")
+    message(STATUS "Looking for clang-tidy - found ${CLANG_TIDY}")
 
     if(BUILD_EXAMPLES)
         file(GLOB CT_ALL_EXAMPLES examples/*.cpp)
@@ -467,41 +456,9 @@ if(CLANG_TIDY)
         ${CT_ALL_BENCHMARKS}
         ${CT_ALL_DATA_TESTS})
 
-    # For a list of check options, see:
-    # http://clang.llvm.org/extra/clang-tidy/checks/list.html
-
-    list(APPEND CT_CHECKS "cert-*"
-                         "-cert-err60-cpp") # even the std lib doesn't do this
-
-    # disabled, because it is slow
-#    list(APPEND CT_CHECKS "clang-analyzer-*")
-
-    list(APPEND CT_CHECKS "google-*"
-                         "-google-explicit-constructor"
-                         "-google-readability-casting"
-                         "-google-readability-function")
-
-    list(APPEND CT_CHECKS "llvm-*"
-                         "-llvm-include-order")
-
-    list(APPEND CT_CHECKS "misc-*"
-                         "-misc-argument-comment")
-
-    list(APPEND CT_CHECKS "modernize-*"
-                          "-modernize-make-unique") # not available in C++11
-
-    list(APPEND CT_CHECKS "readability-*"
-                         "-readability-identifier-naming"
-                         "-readability-implicit-bool-cast"
-                         "-readability-named-parameter")
-
-    string(REPLACE ";" "," ALL_CHECKS "${CT_CHECKS}")
-
     add_custom_target(clang-tidy
         ${CLANG_TIDY}
         -p ${CMAKE_BINARY_DIR}
-        -header-filter='include/osmium/.*'
-        -checks="${ALL_CHECKS}"
         ${CT_CHECK_FILES}
     )
 else()
@@ -523,10 +480,6 @@ if(INSTALL_GDALCPP)
     install(FILES include/gdalcpp.hpp DESTINATION include)
 endif()
 
-if(INSTALL_PROTOZERO)
-    install(DIRECTORY include/protozero DESTINATION include)
-endif()
-
 if(INSTALL_UTFCPP)
     install(FILES include/utf8.h DESTINATION include)
     install(DIRECTORY include/utf8 DESTINATION include)
@@ -560,8 +513,7 @@ include(CPack)
 if(BUILD_DATA_TESTS AND OSM_TESTDATA STREQUAL "OSM_TESTDATA-NOTFOUND")
     message("\n========================== WARNING ==========================")
     message("osm-testdata directory not found, data tests were disabled!\n")
-    message("You can get it from https://github.com/osmcode/osm-testdata")
-    message("Clone it into the same directory libosmium is in")
+    message("Call 'git submodule update --init' to install test data")
     message("or set the OSM_TESTDATA cmake variable to its path.")
     message("=============================================================\n")
 endif()
diff --git a/third_party/libosmium/CONTRIBUTING.md b/third_party/libosmium/CONTRIBUTING.md
index 7e51d4cd47e..a60f507db0c 100644
--- a/third_party/libosmium/CONTRIBUTING.md
+++ b/third_party/libosmium/CONTRIBUTING.md
@@ -10,3 +10,10 @@ Some rules for contributing to this project:
   you have added. Please read the [notes for developers](NOTES_FOR_DEVELOPERS.md)
   beforehand which contains some coding guidelines.
 
+If you are reporting a problem:
+
+* Describe exactly what you were trying to achieve, what you did, what you
+  expected to happen and what did happen instead. Include relevant information
+  about the platform, OS version etc. you are using. Include shell commands you
+  typed in, log files, errors messages etc.
+
diff --git a/third_party/libosmium/EXTERNAL_LICENSES.txt b/third_party/libosmium/EXTERNAL_LICENSES.txt
index 7b06fcf4110..9484c08913f 100644
--- a/third_party/libosmium/EXTERNAL_LICENSES.txt
+++ b/third_party/libosmium/EXTERNAL_LICENSES.txt
@@ -1,210 +1,4 @@
 
-==== For protozero from https://github.com/mapbox/protozero
-
-protozero copyright (c) Mapbox.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in
-      the documentation and/or other materials provided with the
-      distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-==== For protozero from https://github.com/mapbox/protozero
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
 ==== For utf8.h
 
 Copyright 2006 Nemanja Trifunovic
diff --git a/third_party/libosmium/LICENSE.txt b/third_party/libosmium/LICENSE
similarity index 100%
rename from third_party/libosmium/LICENSE.txt
rename to third_party/libosmium/LICENSE
diff --git a/third_party/libosmium/NOTES_FOR_DEVELOPERS.md b/third_party/libosmium/NOTES_FOR_DEVELOPERS.md
index 4bd9d68cf7a..7ffca5ec580 100644
--- a/third_party/libosmium/NOTES_FOR_DEVELOPERS.md
+++ b/third_party/libosmium/NOTES_FOR_DEVELOPERS.md
@@ -126,7 +126,7 @@ Call `cmake/iwyu.sh` to check for proper includes and forward declarations.
 This uses the clang-based `include-what-you-use` program. Note that it does
 produce some false reports and crashes often. The `osmium.imp` file can be
 used to define mappings for iwyu. See the IWYU tool at
-<http://code.google.com/p/include-what-you-use/>.
+<https://include-what-you-use.org/>.
 
 
 ## Testing
diff --git a/third_party/libosmium/README.md b/third_party/libosmium/README.md
index b4fc4dcdb32..91d8f507c35 100644
--- a/third_party/libosmium/README.md
+++ b/third_party/libosmium/README.md
@@ -9,6 +9,7 @@ Libosmium works on Linux, Mac OSX and Windows.
 [![Travis Build Status](https://secure.travis-ci.org/osmcode/libosmium.svg)](https://travis-ci.org/osmcode/libosmium)
 [![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/osmcode/libosmium?svg=true)](https://ci.appveyor.com/project/Mapbox/libosmium)
 [![Coverage Status](https://codecov.io/gh/osmcode/libosmium/branch/master/graph/badge.svg)](https://codecov.io/gh/osmcode/libosmium)
+[![Packaging status](https://repology.org/badge/tiny-repos/libosmium.svg)](https://repology.org/metapackage/libosmium)
 
 Please see the [Libosmium manual](http://osmcode.org/libosmium/manual.html)
 for more details than this README can provide.
@@ -31,9 +32,11 @@ manual.
 The following external (header-only) libraries are included in the libosmium
 repository:
 * [gdalcpp](https://github.com/joto/gdalcpp)
-* [protozero](https://github.com/mapbox/protozero)
 * [utfcpp](http://utfcpp.sourceforge.net/)
 
+Note that [protozero](https://github.com/mapbox/protozero) was included in
+earlier versions of libosmium, but isn't any more.
+
 
 ## Directories
 
@@ -73,6 +76,14 @@ chapter in the manual.
 
 ## Testing
 
+To download the `osm-testdata` submodule call:
+
+```
+git submodule update --init
+```
+
+This will enable additional tests.
+
 See the
 [Libosmium Manual](http://osmcode.org/libosmium/manual.html#running-tests)
 for instructions.
diff --git a/third_party/libosmium/appveyor.yml b/third_party/libosmium/appveyor.yml
index ca77ae64750..2ac3e254665 100644
--- a/third_party/libosmium/appveyor.yml
+++ b/third_party/libosmium/appveyor.yml
@@ -6,34 +6,54 @@
 
 environment:
   matrix:
-  - config: Dev
+  - config: MSYS2
     autocrlf: true
-  - config: Dev
-    autocrlf: false
-  - config: RelWithDebInfo
+  - config: Debug
+    autocrlf: true
+  - config: Release
     autocrlf: true
-  - config: RelWithDebInfo
+  - config: Debug
+    autocrlf: false
+  - config: Release
     autocrlf: false
 
-shallow_clone: true
+clone_depth: 1
 
 # Operating system (build VM template)
 os: Visual Studio 2015
 
+platform: x64
+
 # scripts that are called at very beginning, before repo cloning
 init:
   - git config --global core.autocrlf %autocrlf%
   - git config --get core.autocrlf
 
-# clone directory
 clone_folder: c:\projects\libosmium
 
-platform: x64
+# The option --ask=20 is a workaround for a problem with the MSYS2 update
+# process. Without it the following error is printed and the appveyor script
+# halts: "msys2-runtime and catgets are in conflict. Remove catgets?"
+# See also: https://github.com/Alexpux/MSYS2-packages/issues/1141
+install:
+  - git submodule update --init
+  - cd c:\projects
+  - git clone --depth 1 https://github.com/mapbox/protozero
+  - if [%config%]==[MSYS2] (
+          C:\msys64\usr\bin\pacman --noconfirm --sync --refresh --refresh --sysupgrade --sysupgrade --ask=20
+       && C:\msys64\usr\bin\pacman -Rc --noconfirm mingw-w64-x86_64-gcc-libs
+    )
 
 build_script:
-  - build-appveyor.bat
+  - cd c:\projects\libosmium
+  - if [%config%]==[MSYS2] (
+        build-msys2.bat
+    ) else (
+        build-appveyor.bat
+    )
 
 # remove garbage VS messages
-# http://help.appveyor.com/discussions/problems/4569-the-target-_convertpdbfiles-listed-in-a-beforetargets-attribute-at-c-does-not-exist-in-the-project-and-will-be-ignored
+# https://help.appveyor.com/discussions/problems/4569-the-target-_convertpdbfiles-listed-in-a-beforetargets-attribute-at-c-does-not-exist-in-the-project-and-will-be-ignored
 before_build:
   - del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
+
diff --git a/third_party/libosmium/benchmarks/download_data.sh b/third_party/libosmium/benchmarks/download_data.sh
index be6adb9541d..b17fcad5895 100755
--- a/third_party/libosmium/benchmarks/download_data.sh
+++ b/third_party/libosmium/benchmarks/download_data.sh
@@ -4,9 +4,9 @@
 #
 
 cd $DATA_DIR
-curl --location --output 1_liechtenstein.osm.pbf http://download.geofabrik.de/europe/liechtenstein-latest.osm.pbf   # about   2 MB
-curl --location --output 2_bremen.osm.pbf        http://download.geofabrik.de/europe/germany/bremen-latest.osm.pbf  # about  16 MB
-curl --location --output 3_sachsen.osm.pbf       http://download.geofabrik.de/europe/germany/sachsen-latest.osm.pbf # about 160 MB
-curl --location --output 4_germany.osm.pbf       http://download.geofabrik.de/europe/germany-latest.osm.pbf         # about   3 GB
-curl --location --output 5_planet.osm.pbf        http://planet.osm.org/pbf/planet-latest.osm.pbf                    # about  35 GB
+curl --location --output 1_liechtenstein.osm.pbf https://download.geofabrik.de/europe/liechtenstein-latest.osm.pbf   # about   2 MB
+curl --location --output 2_bremen.osm.pbf        https://download.geofabrik.de/europe/germany/bremen-latest.osm.pbf  # about  16 MB
+curl --location --output 3_sachsen.osm.pbf       https://download.geofabrik.de/europe/germany/sachsen-latest.osm.pbf # about 160 MB
+curl --location --output 4_germany.osm.pbf       https://download.geofabrik.de/europe/germany-latest.osm.pbf         # about   3 GB
+curl --location --output 5_planet.osm.pbf        https://planet.osm.org/pbf/planet-latest.osm.pbf                    # about  35 GB
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp
index 41f9aa07890..65051b0f94f 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp
@@ -4,36 +4,35 @@
 
 */
 
+#include <osmium/handler.hpp>
+#include <osmium/io/any_input.hpp>
+#include <osmium/visitor.hpp>
+
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
 #include <string>
 
-#include <osmium/io/any_input.hpp>
-#include <osmium/handler.hpp>
-#include <osmium/visitor.hpp>
-
 struct CountHandler : public osmium::handler::Handler {
 
     uint64_t nodes = 0;
     uint64_t ways = 0;
     uint64_t relations = 0;
 
-    void node(const osmium::Node&) {
+    void node(const osmium::Node& /*node*/) {
         ++nodes;
     }
 
-    void way(const osmium::Way&) {
+    void way(const osmium::Way& /*way*/) {
         ++ways;
     }
 
-    void relation(const osmium::Relation&) {
+    void relation(const osmium::Relation& /*relation*/) {
         ++relations;
     }
 
 };
 
-
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
@@ -48,8 +47,8 @@ int main(int argc, char* argv[]) {
     osmium::apply(reader, handler);
     reader.close();
 
-    std::cout << "Nodes: "     << handler.nodes << "\n";
-    std::cout << "Ways: "      << handler.ways << "\n";
-    std::cout << "Relations: " << handler.relations << "\n";
+    std::cout << "Nodes: "     << handler.nodes     << '\n';
+    std::cout << "Ways: "      << handler.ways      << '\n';
+    std::cout << "Relations: " << handler.relations << '\n';
 }
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp
index 5b82a7c3abd..12d5c8201ce 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp
@@ -4,15 +4,15 @@
 
 */
 
+#include <osmium/handler.hpp>
+#include <osmium/io/any_input.hpp>
+#include <osmium/visitor.hpp>
+
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
 #include <string>
 
-#include <osmium/io/any_input.hpp>
-#include <osmium/handler.hpp>
-#include <osmium/visitor.hpp>
-
 struct CountHandler : public osmium::handler::Handler {
 
     uint64_t counter = 0;
@@ -26,17 +26,16 @@ struct CountHandler : public osmium::handler::Handler {
         }
     }
 
-    void way(const osmium::Way&) {
+    void way(const osmium::Way& /*way*/) {
         ++all;
     }
 
-    void relation(const osmium::Relation&) {
+    void relation(const osmium::Relation& /*relation*/) {
         ++all;
     }
 
 };
 
-
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
@@ -51,6 +50,6 @@ int main(int argc, char* argv[]) {
     osmium::apply(reader, handler);
     reader.close();
 
-    std::cout << "r_all=" << handler.all << " r_counter="  << handler.counter << "\n";
+    std::cout << "r_all=" << handler.all << " r_counter=" << handler.counter << '\n';
 }
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp
index 2cf550ca9c5..e8989824685 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp
@@ -4,16 +4,15 @@
 
 */
 
-#include <cstdlib>
-#include <iostream>
-#include <string>
-
-#include <osmium/index/map/all.hpp>
+#include <osmium/handler.hpp>
 #include <osmium/handler/node_locations_for_ways.hpp>
+#include <osmium/index/map/all.hpp>
+#include <osmium/io/any_input.hpp>
 #include <osmium/visitor.hpp>
 
-#include <osmium/io/any_input.hpp>
-#include <osmium/handler.hpp>
+#include <cstdlib>
+#include <iostream>
+#include <string>
 
 using index_type = osmium::index::map::Map<osmium::unsigned_object_id_type, osmium::Location>;
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp
index 091e5c025ef..f9672c305ce 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp
@@ -4,17 +4,17 @@
 
 */
 
+#include <osmium/geom/mercator_projection.hpp>
+#include <osmium/geom/wkb.hpp>
+#include <osmium/handler.hpp>
+#include <osmium/io/any_input.hpp>
+#include <osmium/visitor.hpp>
+
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
 #include <string>
 
-#include <osmium/io/any_input.hpp>
-#include <osmium/handler.hpp>
-#include <osmium/visitor.hpp>
-#include <osmium/geom/wkb.hpp>
-#include <osmium/geom/mercator_projection.hpp>
-
 struct GeomHandler : public osmium::handler::Handler {
 
     osmium::geom::WKBFactory<osmium::geom::MercatorProjection> factory;
@@ -25,7 +25,6 @@ struct GeomHandler : public osmium::handler::Handler {
 
 };
 
-
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp
index e9f950c3168..1a689b18785 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp
@@ -16,6 +16,12 @@
 
 */
 
+#include <osmium/handler.hpp>
+#include <osmium/handler/node_locations_for_ways.hpp>
+#include <osmium/index/map/all.hpp>
+#include <osmium/io/any_input.hpp>
+#include <osmium/visitor.hpp>
+
 #include <algorithm>
 #include <chrono>
 #include <cmath>
@@ -24,13 +30,6 @@
 #include <limits>
 #include <string>
 
-#include <osmium/index/map/all.hpp>
-#include <osmium/handler/node_locations_for_ways.hpp>
-#include <osmium/visitor.hpp>
-
-#include <osmium/io/any_input.hpp>
-#include <osmium/handler.hpp>
-
 using static_index_type = osmium::index::map::SparseMemArray<osmium::unsigned_object_id_type, osmium::Location>;
 const std::string location_store{"sparse_mem_array"};
 
@@ -51,7 +50,7 @@ int main(int argc, char* argv[]) {
 
     const auto& map_factory = osmium::index::MapFactory<osmium::unsigned_object_id_type, osmium::Location>::instance();
 
-    const auto buffer_size = buffer.committed() / (1024*1024); // buffer size in MBytes
+    const auto buffer_size = buffer.committed() / (1024 * 1024); // buffer size in MBytes
     const int runs = std::max(10, static_cast<int>(5000ull / buffer_size));
 
     std::cout << "input: filename=" << input_filename << " buffer_size=" << buffer_size << "MBytes\n";
@@ -82,10 +81,14 @@ int main(int argc, char* argv[]) {
             osmium::apply(tmp_buffer, static_location_handler);
             const auto end = std::chrono::steady_clock::now();
 
-            const double duration = std::chrono::duration<double, std::milli>(end-start).count();
+            const double duration = std::chrono::duration<double, std::milli>(end - start).count();
 
-            if (duration < static_min) static_min = duration;
-            if (duration > static_max) static_max = duration;
+            if (duration < static_min) {
+                static_min = duration;
+            }
+            if (duration > static_max) {
+                static_max = duration;
+            }
             static_sum += duration;
         }
 
@@ -105,16 +108,20 @@ int main(int argc, char* argv[]) {
             osmium::apply(tmp_buffer, dynamic_location_handler);
             const auto end = std::chrono::steady_clock::now();
 
-            const double duration = std::chrono::duration<double, std::milli>(end-start).count();
+            const double duration = std::chrono::duration<double, std::milli>(end - start).count();
 
-            if (duration < dynamic_min) dynamic_min = duration;
-            if (duration > dynamic_max) dynamic_max = duration;
+            if (duration < dynamic_min) {
+                dynamic_min = duration;
+            }
+            if (duration > dynamic_max) {
+                dynamic_max = duration;
+            }
             dynamic_sum += duration;
         }
     }
 
-    const double static_avg = static_sum/runs;
-    const double dynamic_avg = dynamic_sum/runs;
+    const double static_avg = static_sum / runs;
+    const double dynamic_avg = dynamic_sum / runs;
 
     std::cout << "static  min=" << static_min << "ms avg=" << static_avg << "ms max=" << static_max << "ms\n";
     std::cout << "dynamic min=" << dynamic_min << "ms avg=" << dynamic_avg << "ms max=" << dynamic_max << "ms\n";
diff --git a/third_party/libosmium/build-appveyor.bat b/third_party/libosmium/build-appveyor.bat
index ef9da5ffd1e..74ea0c91a94 100644
--- a/third_party/libosmium/build-appveyor.bat
+++ b/third_party/libosmium/build-appveyor.bat
@@ -4,73 +4,33 @@ SET EL=0
 
 ECHO ~~~~~~ %~f0 ~~~~~~
 
-SET CUSTOM_CMAKE=cmake-3.6.2-win64-x64
-::show all available env vars
 SET
-ECHO cmake on AppVeyor
-cmake -version
 
 ECHO activating VS cmd prompt && CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
-SET lodir=%CD%
-SET PATH=%lodir%\%CUSTOM_CMAKE%\bin;%PATH%
-SET LODEPSDIR=%lodir%\libosmium-deps
-SET PROJ_LIB=%LODEPSDIR%\proj\share
-SET GDAL_DATA=%LODEPSDIR%\gdal\data
-::gdal.dll
-SET PATH=%LODEPSDIR%\gdal\lib;%PATH%
-::geos.dll
-SET PATH=%LODEPSDIR%\geos\lib;%PATH%
-::libtiff.dll
-SET PATH=%LODEPSDIR%\libtiff\lib;%PATH%
-::jpeg.dll
-SET PATH=%LODEPSDIR%\jpeg\lib;%PATH%
-::libexpat.dll
-SET PATH=%LODEPSDIR%\expat\lib;%PATH%
-::zlibwapi.dll
-SET PATH=%LODEPSDIR%\zlib\lib;%PATH%
-::convert backslashes in bzip2 path to forward slashes
-::cmake cannot find it otherwise
-SET LIBBZIP2=%LODEPSDIR%\bzip2\lib\libbz2.lib
-SET LIBBZIP2=%LIBBZIP2:\=/%
-
-IF NOT EXIST cm.7z ECHO downloading cmake %CUSTOM_CMAKE% ... && powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/%CUSTOM_CMAKE%.7z -OutFile cm.7z
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+CD ..
 
-IF NOT EXIST lodeps.7z ECHO downloading binary dependencies... && powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/libosmium-deps-win-14.0-x64.7z -OutFile lodeps.7z
+nuget install expat.v140 -Version 2.2.5
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
-IF NOT EXIST %CUSTOM_CMAKE% ECHO extracting cmake... && 7z x cm.7z | %windir%\system32\find "ing archive"
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+SET PATH=C:/projects/expat.v140.2.2.5/build/native/bin/x64/%config%;%PATH%
 
-IF NOT EXIST %LODEPSDIR% ECHO extracting binary dependencies... && 7z x lodeps.7z | %windir%\system32\find "ing archive"
+nuget install zlib-vc140-static-64 -Version 1.2.11
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
-ECHO %LODEPSDIR%
-DIR %LODEPSDIR%
-::TREE %LODEPSDIR%
-
-::powershell (Get-ChildItem $env:LODEPSDIR\boost\lib -Filter *boost*.dll)[0].BaseName.split('_')[-1]
-FOR /F "tokens=1 usebackq" %%i in (`powershell ^(Get-ChildItem %LODEPSDIR%\boost\lib -Filter *boost*.dll^)[0].BaseName.split^('_'^)[-1]`) DO SET BOOST_VERSION=%%i
+nuget install bzip2.v140 -Version 1.0.6.9
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
-ECHO BOOST_VERSION^: %BOOST_VERSION%
+SET PATH=C:/projects/bzip2.v140.1.0.6.9/build/native/bin/x64/%config%;%PATH%
 
-ECHO our own cmake
-cmake -version
+CD libosmium
 
-CD %lodir%\..
+ECHO config^: %config%
 
-IF NOT EXIST osm-testdata ECHO cloning osm-testdata && git clone --depth 1 https://github.com/osmcode/osm-testdata.git
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-CD osm-testdata
-git fetch
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-git pull
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+SET libpostfix=""
+IF "%config%"=="Debug" SET libpostfix="d"
 
-CD %lodir%
 IF EXIST build ECHO deleting build dir... && RD /Q /S build
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
@@ -78,20 +38,21 @@ MKDIR build
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
 CD build
-ECHO config^: %config%
 
 ::This will produce lots of LNK4099 warnings which can be ignored.
 ::Unfortunately they can't be disabled, see
-::http://stackoverflow.com/questions/661606/visual-c-how-to-disable-specific-linker-warnings
-SET CMAKE_CMD=cmake .. ^
--LA -G "Visual Studio 14 Win64" ^
+::https://stackoverflow.com/questions/661606/visual-c-how-to-disable-specific-linker-warnings
+SET CMAKE_CMD=cmake .. -LA -G "Visual Studio 14 Win64" ^
 -DOsmium_DEBUG=TRUE ^
 -DCMAKE_BUILD_TYPE=%config% ^
 -DBUILD_HEADERS=OFF ^
--DBOOST_ROOT=%LODEPSDIR%\boost ^
--DZLIB_LIBRARY=%LODEPSDIR%\zlib\lib\zlibwapi.lib ^
--DBZIP2_LIBRARY_RELEASE=%LIBBZIP2% ^
--DCMAKE_PREFIX_PATH=%LODEPSDIR%\zlib;%LODEPSDIR%\expat;%LODEPSDIR%\bzip2;%LODEPSDIR%\geos;%LODEPSDIR%\gdal;%LODEPSDIR%\proj;%LODEPSDIR%\sparsehash;%LODEPSDIR%\wingetopt
+-DBOOST_ROOT=C:/Libraries/boost_1_63_0 ^
+-DZLIB_INCLUDE_DIR=C:/projects/zlib-vc140-static-64.1.2.11/lib/native/include ^
+-DZLIB_LIBRARY=C:/projects/zlib-vc140-static-64.1.2.11/lib/native/libs/x64/static/%config%/zlibstatic.lib ^
+-DEXPAT_INCLUDE_DIR=C:/projects/expat.v140.2.2.5/build/native/include ^
+-DEXPAT_LIBRARY=C:/projects/expat.v140.2.2.5/build/native/lib/x64/%config%/libexpat%libpostfix%.lib ^
+-DBZIP2_INCLUDE_DIR=C:/projects/bzip2.v140.1.0.6.9/build/native/include ^
+-DBZIP2_LIBRARIES=C:/projects/bzip2.v140.1.0.6.9/build/native/lib/x64/%config%/libbz2%libpostfix%.lib
 
 ECHO calling^: %CMAKE_CMD%
 %CMAKE_CMD%
@@ -107,12 +68,9 @@ msbuild libosmium.sln ^
 /p:PlatformToolset=v140 %avlogger%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
-ctest --output-on-failure ^
--C %config% ^
--E testdata-overview
+ctest --output-on-failure -C %config% -E testdata-overview
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
-
 GOTO DONE
 
 :ERROR
diff --git a/third_party/libosmium/build-local.bat b/third_party/libosmium/build-local.bat
index 202d0b2fa68..c2d6e8d9ab3 100644
--- a/third_party/libosmium/build-local.bat
+++ b/third_party/libosmium/build-local.bat
@@ -6,11 +6,11 @@ ECHO ~~~~~~ %~f0 ~~~~~~
 
 ECHO.
 ECHO build-local ["config=Dev"]
-ECHO default config^: RelWithDebInfo
+ECHO default config^: Release
 ECHO.
 
 SET platform=x64
-SET config=RelWithDebInfo
+SET config=Release
 
 :: OVERRIDE PARAMETERS >>>>>>>>
 :NEXT-ARG
@@ -24,9 +24,6 @@ GOTO NEXT-ARG
 :ARGS-DONE
 ::<<<<< OVERRIDE PARAMETERS
 
-WHERE 7z
-IF %ERRORLEVEL% NEQ 0 ECHO 7zip not on PATH && GOTO ERROR
-
 CALL build-appveyor.bat
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
diff --git a/third_party/libosmium/build-msys2.bat b/third_party/libosmium/build-msys2.bat
new file mode 100644
index 00000000000..a4f0f7a1c6e
--- /dev/null
+++ b/third_party/libosmium/build-msys2.bat
@@ -0,0 +1,41 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~ %~f0 ~~~~~~
+
+echo "Adding MSYS2 to path..."
+SET "PATH=C:\msys64\mingw64\bin;C:\msys64\usr\bin;%PATH%"
+echo %PATH%
+
+echo "Installing MSYS2 packages..."
+bash -lc "pacman -S --needed --noconfirm mingw-w64-x86_64-gcc mingw-w64-x86_64-geos mingw-w64-x86_64-cmake mingw-w64-x86_64-boost mingw-w64-x86_64-cppcheck mingw-w64-x86_64-doxygen mingw-w64-x86_64-gdb mingw-w64-x86_64-sparsehash mingw-w64-x86_64-gdal mingw-w64-x86_64-ruby mingw-w64-x86_64-libspatialite mingw-w64-x86_64-spatialite-tools mingw-w64-x86_64-clang-tools-extra"
+bash -lc "pacman -S --needed --noconfirm mingw-w64-x86_64-postgresql mingw-w64-x86_64-netcdf mingw-w64-x86_64-crypto++"
+call C:\msys64\mingw64\bin\gem.cmd install json
+
+echo "Setting PROJ_LIB variable for correct PROJ.4 working"
+set PROJ_LIB=c:\msys64\mingw64\share\proj
+
+echo "Generating makefiles"
+mkdir build
+cd build
+cmake .. -G "MSYS Makefiles" -DBUILD_DATA_TESTS=ON -DBUILD_HEADERS=OFF
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+echo "Building"
+make
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+echo "Testing"
+ctest --output-on-failure
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+:ERROR
+ECHO ~~~~~~ ERROR %~f0 ~~~~~~
+SET EL=%ERRORLEVEL%
+
+:DONE
+IF %EL% NEQ 0 ECHO. && ECHO !!! ERRORLEVEL^: %EL% !!! && ECHO.
+ECHO ~~~~~~ DONE %~f0 ~~~~~~
+
+EXIT /b %EL%
diff --git a/third_party/libosmium/cmake/FindGem.cmake b/third_party/libosmium/cmake/FindGem.cmake
index f5389d1e832..5d78a9026f0 100644
--- a/third_party/libosmium/cmake/FindGem.cmake
+++ b/third_party/libosmium/cmake/FindGem.cmake
@@ -1,5 +1,7 @@
 # Author thomas.roehr@dfki.de
 #
+# Version 0.31 2017-09-15
+#       - find gem executable gem.cmd on Windows
 # Version 0.3 2013-07-02
 #       - rely on `gem content` to find library and header
 #       - introduce GEM_OS_PKG to allow search via pkgconfig
@@ -28,7 +30,7 @@
 # Check for how 'gem' should be called
 include(FindPackageHandleStandardArgs)
 find_program(GEM_EXECUTABLE
-    NAMES "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}"
+    NAMES "gem.cmd" "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}"
         "gem${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}"
         "gem-${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}"
         "gem-${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}"
diff --git a/third_party/libosmium/cmake/FindOsmium.cmake b/third_party/libosmium/cmake/FindOsmium.cmake
index adc457f9a2d..9eaf7349e8f 100644
--- a/third_party/libosmium/cmake/FindOsmium.cmake
+++ b/third_party/libosmium/cmake/FindOsmium.cmake
@@ -54,8 +54,7 @@
 #
 #----------------------------------------------------------------------
 
-# This is the list of directories where we look for osmium and protozero
-# includes.
+# This is the list of directories where we look for osmium includes.
 set(_osmium_include_path
         ../libosmium
         ~/Library/Frameworks
@@ -112,29 +111,14 @@ endif()
 if(Osmium_USE_PBF)
     find_package(ZLIB)
     find_package(Threads)
-
-    message(STATUS "Looking for protozero")
-    find_path(PROTOZERO_INCLUDE_DIR protozero/version.hpp
-        PATH_SUFFIXES include
-        PATHS ${_osmium_include_path}
-              ${OSMIUM_INCLUDE_DIR}
-    )
-    if(PROTOZERO_INCLUDE_DIR)
-        message(STATUS "Looking for protozero - found")
-    else()
-        message(STATUS "Looking for protozero - not found")
-    endif()
+    find_package(Protozero 1.5.1)
 
     list(APPEND OSMIUM_EXTRA_FIND_VARS ZLIB_FOUND Threads_FOUND PROTOZERO_INCLUDE_DIR)
-    if(ZLIB_FOUND AND Threads_FOUND AND PROTOZERO_INCLUDE_DIR)
+    if(ZLIB_FOUND AND Threads_FOUND AND PROTOZERO_FOUND)
         list(APPEND OSMIUM_PBF_LIBRARIES
             ${ZLIB_LIBRARIES}
             ${CMAKE_THREAD_LIBS_INIT}
         )
-        if(WIN32)
-            # This is needed for the ntohl() function
-            list(APPEND OSMIUM_PBF_LIBRARIES ws2_32)
-        endif()
         list(APPEND OSMIUM_INCLUDE_DIRS
             ${ZLIB_INCLUDE_DIR}
             ${PROTOZERO_INCLUDE_DIR}
@@ -361,10 +345,10 @@ endif()
 set(OSMIUM_DRACONIC_CLANG_OPTIONS "-Wdocumentation -Wunused-exception-parameter -Wmissing-declarations -Weverything -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-unused-macros -Wno-exit-time-destructors -Wno-global-constructors -Wno-padded -Wno-switch-enum -Wno-missing-prototypes -Wno-weak-vtables -Wno-cast-align -Wno-float-equal")
 
 if(Osmium_DEBUG)
-    message(STATUS "OSMIUM_XML_LIBRARIES=" ${OSMIUM_XML_LIBRARIES})
-    message(STATUS "OSMIUM_PBF_LIBRARIES=" ${OSMIUM_PBF_LIBRARIES})
-    message(STATUS "OSMIUM_IO_LIBRARIES=" ${OSMIUM_IO_LIBRARIES})
-    message(STATUS "OSMIUM_LIBRARIES=" ${OSMIUM_LIBRARIES})
-    message(STATUS "OSMIUM_INCLUDE_DIRS=" ${OSMIUM_INCLUDE_DIRS})
+    message(STATUS "OSMIUM_XML_LIBRARIES=${OSMIUM_XML_LIBRARIES}")
+    message(STATUS "OSMIUM_PBF_LIBRARIES=${OSMIUM_PBF_LIBRARIES}")
+    message(STATUS "OSMIUM_IO_LIBRARIES=${OSMIUM_IO_LIBRARIES}")
+    message(STATUS "OSMIUM_LIBRARIES=${OSMIUM_LIBRARIES}")
+    message(STATUS "OSMIUM_INCLUDE_DIRS=${OSMIUM_INCLUDE_DIRS}")
 endif()
 
diff --git a/third_party/libosmium/cmake/FindProtozero.cmake b/third_party/libosmium/cmake/FindProtozero.cmake
new file mode 100644
index 00000000000..ad16cabeb00
--- /dev/null
+++ b/third_party/libosmium/cmake/FindProtozero.cmake
@@ -0,0 +1,63 @@
+#----------------------------------------------------------------------
+#
+#  FindProtozero.cmake
+#
+#  Find the protozero headers.
+#
+#----------------------------------------------------------------------
+#
+#  Usage:
+#
+#    Copy this file somewhere into your project directory, where cmake can
+#    find it. Usually this will be a directory called "cmake" which you can
+#    add to the CMake module search path with the following line in your
+#    CMakeLists.txt:
+#
+#      list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+#
+#    Then add the following in your CMakeLists.txt:
+#
+#      find_package(Protozero [version] [REQUIRED])
+#      include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
+#
+#    The version number is optional. If it is not set, any version of
+#    protozero will do.
+#
+#      if(NOT PROTOZERO_FOUND)
+#          message(WARNING "Protozero not found!\n")
+#      endif()
+#
+#----------------------------------------------------------------------
+#
+#  Variables:
+#
+#    PROTOZERO_FOUND        - True if Protozero was found.
+#    PROTOZERO_INCLUDE_DIR  - Where to find include files.
+#
+#----------------------------------------------------------------------
+
+# find include path
+find_path(PROTOZERO_INCLUDE_DIR protozero/version.hpp
+    PATH_SUFFIXES include
+    PATHS ${CMAKE_SOURCE_DIR}/../protozero
+)
+
+# Check version number
+if(Protozero_FIND_VERSION)
+    file(STRINGS "${PROTOZERO_INCLUDE_DIR}/protozero/version.hpp" _version_define REGEX "#define PROTOZERO_VERSION_STRING")
+    if("${_version_define}" MATCHES "#define PROTOZERO_VERSION_STRING \"([0-9.]+)\"")
+        set(_version "${CMAKE_MATCH_1}")
+    else()
+        set(_version "unknown")
+    endif()
+endif()
+
+#set(PROTOZERO_INCLUDE_DIRS "${PROTOZERO_INCLUDE_DIR}")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Protozero
+                                  REQUIRED_VARS PROTOZERO_INCLUDE_DIR
+                                  VERSION_VAR _version)
+
+
+#----------------------------------------------------------------------
diff --git a/third_party/libosmium/examples/CMakeLists.txt b/third_party/libosmium/examples/CMakeLists.txt
index c4f875f43d2..c1498cc3522 100644
--- a/third_party/libosmium/examples/CMakeLists.txt
+++ b/third_party/libosmium/examples/CMakeLists.txt
@@ -30,25 +30,6 @@ set(EXAMPLES
 )
 
 
-#-----------------------------------------------------------------------------
-#
-#  Examples depending on wingetopt
-#
-#-----------------------------------------------------------------------------
-set(GETOPT_EXAMPLES area_test convert index_lookup)
-if(NOT GETOPT_MISSING)
-    foreach(example ${GETOPT_EXAMPLES})
-        list(APPEND EXAMPLE_LIBS_${example} ${GETOPT_LIBRARY})
-    endforeach()
-else()
-    message(STATUS "Configuring examples - Skipping examples because on Visual Studio the wingetopt library is needed and was not found:")
-    foreach(example ${GETOPT_EXAMPLES})
-        message(STATUS "  - osmium_${example}")
-        list(REMOVE_ITEM EXAMPLES ${example})
-    endforeach()
-endif()
-
-
 #-----------------------------------------------------------------------------
 #
 #  Configure examples
diff --git a/third_party/libosmium/examples/osmium_area_test.cpp b/third_party/libosmium/examples/osmium_area_test.cpp
index 948c032ed19..5a29472e5a4 100644
--- a/third_party/libosmium/examples/osmium_area_test.cpp
+++ b/third_party/libosmium/examples/osmium_area_test.cpp
@@ -26,7 +26,7 @@
 */
 
 #include <cstdlib>  // for std::exit
-#include <getopt.h> // for getopt_long
+#include <cstring>  // for std::strcmp
 #include <iostream> // for std::cout, std::cerr
 
 // For assembling multipolygons
@@ -91,13 +91,21 @@ void print_help() {
               << "  -o, --dump-objects   Dump area objects\n";
 }
 
+void print_usage(const char* prgname) {
+    std::cerr << "Usage: " << prgname << " [OPTIONS] OSMFILE\n";
+    std::exit(1);
+}
+
 int main(int argc, char* argv[]) {
-    static struct option long_options[] = {
-        {"help",         no_argument, nullptr, 'h'},
-        {"dump-wkt",     no_argument, nullptr, 'w'},
-        {"dump-objects", no_argument, nullptr, 'o'},
-        {nullptr, 0, nullptr, 0}
-    };
+    if (argc > 1 && (!std::strcmp(argv[1], "-h") ||
+                     !std::strcmp(argv[1], "--help"))) {
+        print_help();
+        std::exit(0);
+    }
+
+    if (argc != 3) {
+        print_usage(argv[0]);
+    }
 
     // Initialize an empty DynamicHandler. Later it will be associated
     // with one of the handlers. You can think of the DynamicHandler as
@@ -105,35 +113,15 @@ int main(int argc, char* argv[]) {
     // real handler.
     osmium::handler::DynamicHandler handler;
 
-    // Read options from command line.
-    while (true) {
-        const int c = getopt_long(argc, argv, "hwo", long_options, nullptr);
-        if (c == -1) {
-            break;
-        }
-
-        switch (c) {
-            case 'h':
-                print_help();
-                std::exit(0);
-            case 'w':
-                handler.set<WKTDump>();
-                break;
-            case 'o':
-                handler.set<osmium::handler::Dump>(std::cout);
-                break;
-            default:
-                std::exit(1);
-        }
-    }
-
-    const int remaining_args = argc - optind;
-    if (remaining_args != 1) {
-        std::cerr << "Usage: " << argv[0] << " [OPTIONS] OSMFILE\n";
-        std::exit(1);
+    if (!std::strcmp(argv[1], "-w") || !std::strcmp(argv[1], "--dump-wkt")) {
+        handler.set<WKTDump>();
+    } else if (!std::strcmp(argv[1], "-o") || !std::strcmp(argv[1], "--dump-objects")) {
+        handler.set<osmium::handler::Dump>(std::cout);
+    } else {
+        print_usage(argv[0]);
     }
 
-    osmium::io::File input_file{argv[optind]};
+    osmium::io::File input_file{argv[2]};
 
     // Configuration for the multipolygon assembler. Here the default settings
     // are used, but you could change multiple settings.
diff --git a/third_party/libosmium/examples/osmium_change_tags.cpp b/third_party/libosmium/examples/osmium_change_tags.cpp
index ae2e99e9880..e00ee0339fe 100644
--- a/third_party/libosmium/examples/osmium_change_tags.cpp
+++ b/third_party/libosmium/examples/osmium_change_tags.cpp
@@ -76,14 +76,14 @@ class RewriteHandler : public osmium::handler::Handler {
         // Iterate over all tags and build new tags using the new builder
         // based on the old ones.
         for (const auto& tag : tags) {
-            if (std::strcmp(tag.key(), "created_by")) {
-                if (!std::strcmp(tag.key(), "landuse") && !std::strcmp(tag.value(), "forest")) {
-                    // add_tag() can be called with key and value C strings
-                    builder.add_tag("natural", "wood");
-                } else {
-                    // add_tag() can also be called with an osmium::Tag
-                    builder.add_tag(tag);
-                }
+            if (!std::strcmp(tag.key(), "created_by")) {
+                // ignore
+            } else if (!std::strcmp(tag.key(), "landuse") && !std::strcmp(tag.value(), "forest")) {
+                // add_tag() can be called with key and value C strings
+                builder.add_tag("natural", "wood");
+            } else {
+                // add_tag() can also be called with an osmium::Tag
+                builder.add_tag(tag);
             }
         }
     }
diff --git a/third_party/libosmium/examples/osmium_convert.cpp b/third_party/libosmium/examples/osmium_convert.cpp
index dfa0abd4a6e..d28663b893d 100644
--- a/third_party/libosmium/examples/osmium_convert.cpp
+++ b/third_party/libosmium/examples/osmium_convert.cpp
@@ -18,8 +18,8 @@
 */
 
 #include <cstdlib>   // for std::exit
+#include <cstring>   // for std::strcmp
 #include <exception> // for std::exception
-#include <getopt.h>  // for getopt_long
 #include <iostream>  // for std::cout, std::cerr
 #include <string>    // for std::string
 
@@ -51,13 +51,21 @@ void print_help() {
               << "  -t, --to-format=FORMAT    Output format\n";
 }
 
+void print_usage(const char* prgname) {
+    std::cerr << "Usage: " << prgname << " [OPTIONS] [INFILE [OUTFILE]]\n";
+    std::exit(0);
+}
+
 int main(int argc, char* argv[]) {
-    static struct option long_options[] = {
-        {"help",              no_argument, nullptr, 'h'},
-        {"from-format", required_argument, nullptr, 'f'},
-        {"to-format",   required_argument, nullptr, 't'},
-        {nullptr, 0, nullptr, 0}
-    };
+    if (argc == 1) {
+        print_usage(argv[0]);
+    }
+
+    if (argc > 1 && (!std::strcmp(argv[1], "-h") ||
+                     !std::strcmp(argv[1], "--help"))) {
+        print_help();
+        std::exit(0);
+    }
 
     // Input and output format are empty by default. Later this will mean that
     // the format should be taken from the input and output file suffix,
@@ -65,44 +73,35 @@ int main(int argc, char* argv[]) {
     std::string input_format;
     std::string output_format;
 
-    // Read options from command line.
-    while (true) {
-        const int c = getopt_long(argc, argv, "dhf:t:", long_options, nullptr);
-        if (c == -1) {
-            break;
-        }
-
-        switch (c) {
-            case 'h':
-                print_help();
-                std::exit(0);
-            case 'f':
-                input_format = optarg;
-                break;
-            case 't':
-                output_format = optarg;
-                break;
-            default:
-                std::exit(1);
-        }
-    }
-
-    const int remaining_args = argc - optind;
-    if (remaining_args == 0 || remaining_args > 2) {
-        std::cerr << "Usage: " << argv[0] << " [OPTIONS] [INFILE [OUTFILE]]\n";
-        std::exit(1);
-    }
-
-    // Get input file name from command line.
     std::string input_file_name;
-    if (remaining_args >= 1) {
-        input_file_name = argv[optind];
-    }
-
-    // Get output file name from command line.
     std::string output_file_name;
-    if (remaining_args == 2) {
-        output_file_name = argv[optind+1];
+
+    for (int i = 1; i < argc; ++i) {
+        if (!std::strcmp(argv[i], "-f") || !std::strcmp(argv[i], "--from-format")) {
+            ++i;
+            if (i < argc) {
+                input_format = argv[i];
+            } else {
+                print_usage(argv[0]);
+            }
+        } else if (!std::strncmp(argv[i], "--from-format=", 14)) {
+            input_format = argv[i] + 14;
+        } else if (!std::strcmp(argv[i], "-t") || !std::strcmp(argv[i], "--to-format")) {
+            ++i;
+            if (i < argc) {
+                output_format = argv[i];
+            } else {
+                print_usage(argv[0]);
+            }
+        } else if (!std::strncmp(argv[i], "--to-format=", 12)) {
+            output_format = argv[i] + 12;
+        } else if (input_file_name.empty()) {
+            input_file_name = argv[i];
+        } else if (output_file_name.empty()) {
+            output_file_name = argv[i];
+        } else {
+            print_usage(argv[0]);
+        }
     }
 
     // This declares the input and output files using either the suffix of
diff --git a/third_party/libosmium/examples/osmium_count.cpp b/third_party/libosmium/examples/osmium_count.cpp
index 7de1b6b7c6e..130b98a0ccc 100644
--- a/third_party/libosmium/examples/osmium_count.cpp
+++ b/third_party/libosmium/examples/osmium_count.cpp
@@ -43,17 +43,17 @@ struct CountHandler : public osmium::handler::Handler {
     std::uint64_t relations = 0;
 
     // This callback is called by osmium::apply for each node in the data.
-    void node(const osmium::Node&) noexcept {
+    void node(const osmium::Node& /*node*/) noexcept {
         ++nodes;
     }
 
     // This callback is called by osmium::apply for each way in the data.
-    void way(const osmium::Way&) noexcept {
+    void way(const osmium::Way& /*way*/) noexcept {
         ++ways;
     }
 
     // This callback is called by osmium::apply for each relation in the data.
-    void relation(const osmium::Relation&) noexcept {
+    void relation(const osmium::Relation& /*relation*/) noexcept {
         ++relations;
     }
 
diff --git a/third_party/libosmium/examples/osmium_create_pois.cpp b/third_party/libosmium/examples/osmium_create_pois.cpp
index df27bfeff7b..dedbdb88aa2 100644
--- a/third_party/libosmium/examples/osmium_create_pois.cpp
+++ b/third_party/libosmium/examples/osmium_create_pois.cpp
@@ -31,11 +31,8 @@
 #include <osmium/io/any_output.hpp>
 
 // We want to use the builder interface
-#include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/builder/attr.hpp>
-
-// Declare this to use the functions starting with the underscore (_) below.
-using namespace osmium::builder::attr;
+#include <osmium/builder/osm_object_builder.hpp>
 
 int main(int argc, char* argv[]) {
     if (argc != 2) {
@@ -56,6 +53,9 @@ int main(int argc, char* argv[]) {
         const size_t initial_buffer_size = 10000;
         osmium::memory::Buffer buffer{initial_buffer_size, osmium::memory::Buffer::auto_grow::yes};
 
+        // Declare this to use the functions starting with the underscore (_) below.
+        using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
+
         // Add nodes to the buffer. This is, of course, only an example.
         // You can set any of the attributes and more tags, etc. Ways and
         // relations can be added in a similar way.
diff --git a/third_party/libosmium/examples/osmium_dump_internal.cpp b/third_party/libosmium/examples/osmium_dump_internal.cpp
index 78229dadcd5..39523fa5472 100644
--- a/third_party/libosmium/examples/osmium_dump_internal.cpp
+++ b/third_party/libosmium/examples/osmium_dump_internal.cpp
@@ -29,8 +29,8 @@
 */
 
 #include <cerrno>      // for errno
-#include <cstring>     // for std::strerror
 #include <cstdlib>     // for std::exit
+#include <cstring>     // for std::strerror
 #include <iostream>    // for std::cout, std::cerr
 #include <string>      // for std::string
 #include <sys/stat.h>  // for open
@@ -71,7 +71,7 @@ class IndexFile {
 public:
 
     explicit IndexFile(const std::string& filename) :
-        m_fd(::open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666)) {
+        m_fd(::open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666)) { // NOLINT(hicpp-signed-bitwise)
         if (m_fd < 0) {
             std::cerr << "Can't open index file '" << filename << "': " << std::strerror(errno) << "\n";
             std::exit(2);
@@ -81,6 +81,12 @@ class IndexFile {
 #endif
     }
 
+    IndexFile(const IndexFile&) = delete;
+    IndexFile& operator=(const IndexFile&) = delete;
+
+    IndexFile(IndexFile&&) = delete;
+    IndexFile& operator=(IndexFile&&) = delete;
+
     ~IndexFile() {
         if (m_fd >= 0) {
             close(m_fd);
@@ -115,7 +121,7 @@ int main(int argc, char* argv[]) {
 
     // Create the output file which will contain our serialized OSM data
     const std::string data_file{output_dir + "/data.osm.ser"};
-    const int data_fd = ::open(data_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
+    const int data_fd = ::open(data_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666); // NOLINT(hicpp-signed-bitwise)
     if (data_fd < 0) {
         std::cerr << "Can't open data file '" << data_file << "': " << std::strerror(errno) << "\n";
         std::exit(2);
diff --git a/third_party/libosmium/examples/osmium_filter_discussions.cpp b/third_party/libosmium/examples/osmium_filter_discussions.cpp
index c2a94e5a272..c4d092a0a38 100644
--- a/third_party/libosmium/examples/osmium_filter_discussions.cpp
+++ b/third_party/libosmium/examples/osmium_filter_discussions.cpp
@@ -3,7 +3,7 @@
   EXAMPLE osmium_filter_discussions
 
   Read OSM changesets with discussions from a changeset dump like the one
-  you get from http://planet.osm.org/planet/discussions-latest.osm.bz2
+  you get from https://planet.osm.org/planet/discussions-latest.osm.bz2
   and write out only those changesets which have discussions (ie comments).
 
   DEMONSTRATES USE OF:
diff --git a/third_party/libosmium/examples/osmium_index_lookup.cpp b/third_party/libosmium/examples/osmium_index_lookup.cpp
index 2af2378339d..2f428bf7cd5 100644
--- a/third_party/libosmium/examples/osmium_index_lookup.cpp
+++ b/third_party/libosmium/examples/osmium_index_lookup.cpp
@@ -24,8 +24,8 @@
 
 #include <algorithm>   // for std::all_of, std::equal_range
 #include <cstdlib>     // for std::exit
+#include <cstring>     // for std::strcmp
 #include <fcntl.h>     // for open
-#include <getopt.h>    // for getopt_long
 #include <iostream>    // for std::cout, std::cerr
 #include <memory>      // for std::unique_ptr
 #include <string>      // for std::string
@@ -64,6 +64,12 @@ class IndexAccess {
         return m_fd;
     }
 
+    IndexAccess(const IndexAccess&) = delete;
+    IndexAccess& operator=(const IndexAccess&) = delete;
+
+    IndexAccess(IndexAccess&&) = delete;
+    IndexAccess& operator=(IndexAccess&&) = delete;
+
     virtual ~IndexAccess() = default;
 
     virtual void dump() const = 0;
@@ -83,7 +89,7 @@ class IndexAccess {
 template <typename TValue>
 class IndexAccessDense : public IndexAccess<TValue> {
 
-    using index_type  = typename osmium::index::map::DenseFileArray<osmium::unsigned_object_id_type, TValue>;
+    using index_type = typename osmium::index::map::DenseFileArray<osmium::unsigned_object_id_type, TValue>;
 
 public:
 
@@ -187,58 +193,70 @@ class Options {
         ;
     }
 
+    void print_usage(const char* prgname) {
+        std::cout << "Usage: " << prgname << " [OPTIONS]\n\n";
+        std::exit(0);
+    }
+
 public:
 
     Options(int argc, char* argv[]) {
         if (argc == 1) {
-            print_help();
-            std::exit(1);
+            print_usage(argv[0]);
         }
 
-        static struct option long_options[] = {
-            {"array",  required_argument, nullptr, 'a'},
-            {"dump",         no_argument, nullptr, 'd'},
-            {"help",         no_argument, nullptr, 'h'},
-            {"list",   required_argument, nullptr, 'l'},
-            {"search", required_argument, nullptr, 's'},
-            {"type",   required_argument, nullptr, 't'},
-            {nullptr, 0, nullptr, 0}
-        };
-
-        while (true) {
-            const int c = getopt_long(argc, argv, "a:dhl:s:t:", long_options, nullptr);
-            if (c == -1) {
-                break;
-            }
+        if (argc > 1 && (!std::strcmp(argv[1], "-h") ||
+                         !std::strcmp(argv[1], "--help"))) {
+            print_help();
+            std::exit(0);
+        }
 
-            switch (c) {
-                case 'a':
+        for (int i = 1; i < argc; ++i) {
+            if (!std::strcmp(argv[i], "-a") || !std::strcmp(argv[i], "--array")) {
+                ++i;
+                if (i < argc) {
                     m_array_format = true;
-                    m_filename = optarg;
-                    break;
-                case 'd':
-                    m_dump = true;
-                    break;
-                case 'h':
-                    print_help();
-                    std::exit(0);
-                case 'l':
+                    m_filename = argv[i];
+                } else {
+                    print_usage(argv[0]);
+                }
+            } else if (!std::strncmp(argv[i], "--array=", 8)) {
+                m_array_format = true;
+                m_filename = argv[i] + 8;
+            } else if (!std::strcmp(argv[i], "-l") || !std::strcmp(argv[i], "--list")) {
+                ++i;
+                if (i < argc) {
                     m_list_format = true;
-                    m_filename = optarg;
-                    break;
-                case 's':
-                    m_ids.push_back(std::atoll(optarg));
-                    break;
-                case 't':
-                    m_type = optarg;
-                    if (m_type != "location" && m_type != "id" && m_type != "offset") {
-                        std::cerr << "Unknown type '" << m_type
-                                  << "'. Must be 'location', 'id', or 'offset'.\n";
-                        std::exit(2);
-                    }
-                    break;
-                default:
-                    std::exit(2);
+                    m_filename = argv[i];
+                } else {
+                    print_usage(argv[0]);
+                }
+            } else if (!std::strncmp(argv[i], "--list=", 7)) {
+                m_list_format = true;
+                m_filename = argv[i] + 7;
+            } else if (!std::strcmp(argv[i], "-d") || !std::strcmp(argv[i], "--dump")) {
+                m_dump = true;
+            } else if (!std::strcmp(argv[i], "-s") || !std::strcmp(argv[i], "--search")) {
+                ++i;
+                if (i < argc) {
+                    m_ids.push_back(std::atoll(argv[i])); // NOLINT(cert-err34-c)
+                } else {
+                    print_usage(argv[0]);
+                }
+            } else if (!std::strncmp(argv[i], "--search=", 9)) {
+                m_ids.push_back(std::atoll(argv[i] + 9)); // NOLINT(cert-err34-c)
+            } else if (!std::strcmp(argv[i], "-t") || !std::strcmp(argv[i], "--type")) {
+                ++i;
+                if (i < argc) {
+                    m_type = argv[i];
+                } else {
+                    print_usage(argv[0]);
+                }
+            } else if (!std::strncmp(argv[i], "--type=", 7)) {
+                m_type = argv[i] + 7;
+            } else {
+                std::cerr << "Unknown command line options or arguments\n";
+                print_usage(argv[0]);
             }
         }
 
@@ -257,6 +275,11 @@ class Options {
             std::exit(2);
         }
 
+        if (m_type != "location" && m_type != "id" && m_type != "offset") {
+            std::cerr << "Unknown type '" << m_type
+                      << "'. Must be 'location', 'id', or 'offset'.\n";
+            std::exit(2);
+        }
     }
 
     const char* filename() const noexcept {
@@ -302,9 +325,8 @@ int run(const IndexAccess<TValue>& index, const Options& options) {
     if (options.do_dump()) {
         index.dump();
         return 0;
-    } else {
-        return index.search(options.search_keys()) ? 0 : 1;
     }
+    return index.search(options.search_keys()) ? 0 : 1;
 }
 
 int main(int argc, char* argv[]) {
@@ -329,16 +351,18 @@ int main(int argc, char* argv[]) {
             // index id -> location
             const auto index = create<osmium::Location>(options.dense_format(), fd);
             return run(*index, options);
-        } else if (options.type_is("id")) {
+        }
+
+        if (options.type_is("id")) {
             // index id -> id
             const auto index = create<osmium::unsigned_object_id_type>(options.dense_format(), fd);
             return run(*index, options);
-        } else {
-            // index id -> offset
-            const auto index = create<std::size_t>(options.dense_format(), fd);
-            return run(*index, options);
         }
-    } catch(const std::exception& e) {
+
+        // index id -> offset
+        const auto index = create<std::size_t>(options.dense_format(), fd);
+        return run(*index, options);
+    } catch (const std::exception& e) {
         std::cerr << "Error: " << e.what() << '\n';
         std::exit(1);
     }
diff --git a/third_party/libosmium/examples/osmium_location_cache_create.cpp b/third_party/libosmium/examples/osmium_location_cache_create.cpp
index a7119df6048..d1b381082e3 100644
--- a/third_party/libosmium/examples/osmium_location_cache_create.cpp
+++ b/third_party/libosmium/examples/osmium_location_cache_create.cpp
@@ -42,8 +42,8 @@
 
 // For the location index. There are different types of index implementation
 // available. These implementations put the index on disk. See below.
-#include <osmium/index/map/sparse_file_array.hpp>
 #include <osmium/index/map/dense_file_array.hpp>
+#include <osmium/index/map/sparse_file_array.hpp>
 
 // For the NodeLocationForWays handler
 #include <osmium/handler/node_locations_for_ways.hpp>
@@ -72,7 +72,7 @@ int main(int argc, char* argv[]) {
     osmium::io::Reader reader{input_filename, osmium::osm_entity_bits::node};
 
     // Initialize location index on disk creating a new file.
-    const int fd = ::open(cache_filename.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666);
+    const int fd = ::open(cache_filename.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666); // NOLINT(hicpp-signed-bitwise)
     if (fd == -1) {
         std::cerr << "Can not open location cache file '" << cache_filename << "': " << std::strerror(errno) << "\n";
         std::exit(1);
diff --git a/third_party/libosmium/examples/osmium_read_with_progress.cpp b/third_party/libosmium/examples/osmium_read_with_progress.cpp
index 81437a665df..415e78de886 100644
--- a/third_party/libosmium/examples/osmium_read_with_progress.cpp
+++ b/third_party/libosmium/examples/osmium_read_with_progress.cpp
@@ -38,7 +38,7 @@ int main(int argc, char* argv[]) {
     osmium::io::Reader reader{input_file};
 
     // Initialize progress bar, enable it only if STDERR is a TTY.
-    osmium::ProgressBar progress{reader.file_size(), osmium::util::isatty(2)};
+    osmium::ProgressBar progress{reader.file_size(), osmium::isatty(2)};
 
     // OSM data comes in buffers, read until there are no more.
     while (osmium::memory::Buffer buffer = reader.read()) {
diff --git a/third_party/libosmium/examples/osmium_tiles.cpp b/third_party/libosmium/examples/osmium_tiles.cpp
index 7dbeb3e29ae..52a1a1f5d91 100644
--- a/third_party/libosmium/examples/osmium_tiles.cpp
+++ b/third_party/libosmium/examples/osmium_tiles.cpp
@@ -36,21 +36,21 @@ int main(int argc, char* argv[]) {
         std::exit(1);
     }
 
-    const int zoom = std::atoi(argv[1]);
+    const int zoom = std::atoi(argv[1]); // NOLINT(cert-err34-c)
 
     if (zoom < 0 || zoom > 30) {
         std::cerr << "ERROR: Zoom must be between 0 and 30\n";
         std::exit(1);
     }
 
-    const double lon = std::atof(argv[2]);
-    const double lat = std::atof(argv[3]);
-
-    // Create location from WGS84 coordinates. In Osmium the order of
-    // coordinate values is always x/longitude first, then y/latitude.
-    const osmium::Location location{lon, lat};
-
-    std::cout << "WGS84:    lon=" << lon << " lat=" << lat << "\n";
+    osmium::Location location{};
+    try {
+        location.set_lon(argv[2]);
+        location.set_lat(argv[3]);
+    } catch (const osmium::invalid_location&) {
+        std::cerr << "ERROR: Location is invalid\n";
+        std::exit(1);
+    }
 
     // A location can store some invalid locations, ie locations outside the
     // -180 to 180 and -90 to 90 degree range. This function checks for that.
@@ -59,6 +59,8 @@ int main(int argc, char* argv[]) {
         std::exit(1);
     }
 
+    std::cout << "WGS84:    lon=" << location.lon() << " lat=" << location.lat() << "\n";
+
     // Project the coordinates using a helper function. You can also use the
     // osmium::geom::MercatorProjection class.
     const osmium::geom::Coordinates c = osmium::geom::lonlat_to_mercator(location);
diff --git a/third_party/libosmium/include/osmium/area/assembler.hpp b/third_party/libosmium/include/osmium/area/assembler.hpp
index 461a1837613..29fd6a5968b 100644
--- a/third_party/libosmium/include/osmium/area/assembler.hpp
+++ b/third_party/libosmium/include/osmium/area/assembler.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <iostream>
-#include <vector>
-
 #include <osmium/area/assembler_config.hpp>
 #include <osmium/area/detail/basic_assembler_with_tags.hpp>
 #include <osmium/area/detail/segment_list.hpp>
@@ -50,6 +46,10 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/tag.hpp>
 #include <osmium/osm/way.hpp>
 
+#include <cassert>
+#include <iostream>
+#include <vector>
+
 namespace osmium {
 
     namespace area {
@@ -111,8 +111,6 @@ namespace osmium {
                 detail::BasicAssemblerWithTags(config) {
             }
 
-            ~Assembler() noexcept = default;
-
             /**
              * Assemble an area from the given way.
              * The resulting area is put into the out_buffer.
diff --git a/third_party/libosmium/include/osmium/area/assembler_config.hpp b/third_party/libosmium/include/osmium/area/assembler_config.hpp
index 24bd60a99d2..fce53badb0a 100644
--- a/third_party/libosmium/include/osmium/area/assembler_config.hpp
+++ b/third_party/libosmium/include/osmium/area/assembler_config.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/area/assembler_legacy.hpp b/third_party/libosmium/include/osmium/area/assembler_legacy.hpp
index e616c947cb1..2531ad863d7 100644
--- a/third_party/libosmium/include/osmium/area/assembler_legacy.hpp
+++ b/third_party/libosmium/include/osmium/area/assembler_legacy.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,18 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cassert>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <iterator>
-#include <set>
-#include <string>
-#include <map>
-#include <utility>
-#include <vector>
-
 #include <osmium/area/assembler_config.hpp>
 #include <osmium/area/detail/basic_assembler_with_tags.hpp>
 #include <osmium/area/detail/proto_ring.hpp>
@@ -62,6 +50,18 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/way.hpp>
 #include <osmium/tags/filter.hpp>
 
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
 namespace osmium {
 
     namespace area {
@@ -207,8 +207,6 @@ namespace osmium {
                 detail::BasicAssemblerWithTags(config) {
             }
 
-            ~AssemblerLegacy() noexcept = default;
-
             /**
              * Assemble an area from the given way.
              * The resulting area is put into the out_buffer.
@@ -335,7 +333,7 @@ namespace osmium {
                 if (stats().wrong_role == 0) {
                     detail::for_each_member(relation, members, [this, &ways_that_should_be_areas, &area_tags](const osmium::RelationMember& member, const osmium::Way& way) {
                         if (!std::strcmp(member.role(), "inner")) {
-                            if (!way.nodes().empty() && way.is_closed() && way.tags().size() > 0) {
+                            if (!way.nodes().empty() && way.is_closed() && !way.tags().empty()) {
                                 const auto d = std::count_if(way.tags().cbegin(), way.tags().cend(), std::cref(filter()));
                                 if (d > 0) {
                                     osmium::tags::KeyFilter::iterator way_fi_begin(std::cref(filter()), way.tags().cbegin(), way.tags().cend());
diff --git a/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp b/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp
index 94168a12d5f..485d2223923 100644
--- a/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,20 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/area/assembler_config.hpp>
+#include <osmium/area/detail/node_ref_segment.hpp>
+#include <osmium/area/detail/proto_ring.hpp>
+#include <osmium/area/detail/segment_list.hpp>
+#include <osmium/area/problem_reporter.hpp>
+#include <osmium/area/stats.hpp>
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/util/iterator.hpp>
+#include <osmium/util/timer.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
@@ -45,21 +59,6 @@ DEALINGS IN THE SOFTWARE.
 #include <utility>
 #include <vector>
 
-#include <osmium/builder/osm_object_builder.hpp>
-#include <osmium/osm/location.hpp>
-#include <osmium/osm/node_ref.hpp>
-#include <osmium/osm/types.hpp>
-#include <osmium/osm/way.hpp>
-#include <osmium/util/iterator.hpp>
-#include <osmium/util/timer.hpp>
-
-#include <osmium/area/assembler_config.hpp>
-#include <osmium/area/detail/node_ref_segment.hpp>
-#include <osmium/area/detail/proto_ring.hpp>
-#include <osmium/area/detail/segment_list.hpp>
-#include <osmium/area/problem_reporter.hpp>
-#include <osmium/area/stats.hpp>
-
 namespace osmium {
 
     namespace area {
@@ -70,19 +69,17 @@ namespace osmium {
 
             struct location_to_ring_map {
                 osmium::Location location;
-                open_ring_its_type::iterator ring_it;
-                bool start;
+                open_ring_its_type::iterator ring_it{};
+                bool start{false};
 
-                location_to_ring_map(const osmium::Location& l, const open_ring_its_type::iterator& r, bool s) noexcept :
+                location_to_ring_map(osmium::Location l, open_ring_its_type::iterator r, const bool s) noexcept :
                     location(l),
                     ring_it(r),
                     start(s) {
                 }
 
-                explicit location_to_ring_map(const osmium::Location& l) noexcept :
-                    location(l),
-                    ring_it(),
-                    start(false) {
+                explicit location_to_ring_map(osmium::Location l) noexcept :
+                    location(l) {
                 }
 
                 const ProtoRing& ring() const noexcept {
@@ -108,7 +105,7 @@ namespace osmium {
 
                 struct slocation {
 
-                    static constexpr const uint32_t invalid_item = 1 << 30;
+                    static constexpr const uint32_t invalid_item = 1u << 30u;
 
                     uint32_t item : 31;
                     uint32_t reverse : 1;
@@ -320,7 +317,7 @@ namespace osmium {
                             const int64_t ly = end_location.y();
                             const auto z = (bx - ax)*(ly - ay) - (by - ay)*(lx - ax);
                             if (debug()) {
-                                std::cerr << "      Segment XXXX z=" << z << "\n";
+                                std::cerr << "      Segment z=" << z << '\n';
                             }
                             if (z > 0) {
                                 nesting += segment->is_reverse() ? -1 : 1;
@@ -623,8 +620,8 @@ namespace osmium {
                 }
 
                 void merge_two_rings(open_ring_its_type& open_ring_its, const location_to_ring_map& m1, const location_to_ring_map& m2) {
-                    std::list<ProtoRing>::iterator r1 = *m1.ring_it;
-                    std::list<ProtoRing>::iterator r2 = *m2.ring_it;
+                    const auto r1 = *m1.ring_it;
+                    const auto r2 = *m2.ring_it;
 
                     if (r1->get_node_ref_stop().location() == r2->get_node_ref_start().location()) {
                         r1->join_forward(*r2);
@@ -689,13 +686,12 @@ namespace osmium {
 
                 struct candidate {
                     int64_t sum;
-                    std::vector<std::pair<location_to_ring_map, bool>> rings;
+                    std::vector<std::pair<location_to_ring_map, bool>> rings{};
                     osmium::Location start_location;
                     osmium::Location stop_location;
 
                     explicit candidate(location_to_ring_map& ring, bool reverse) :
                         sum(ring.ring().sum()),
-                        rings(),
                         start_location(ring.ring().get_node_ref_start().location()),
                         stop_location(ring.ring().get_node_ref_stop().location()) {
                         rings.emplace_back(ring, reverse);
@@ -813,8 +809,8 @@ namespace osmium {
                             ++m_stats.open_rings;
                             if (m_config.problem_reporter) {
                                 for (auto& it : open_ring_its) {
-                                    m_config.problem_reporter->report_ring_not_closed(it->get_node_ref_start());
-                                    m_config.problem_reporter->report_ring_not_closed(it->get_node_ref_stop());
+                                    m_config.problem_reporter->report_ring_not_closed(it->get_node_ref_start(), nullptr);
+                                    m_config.problem_reporter->report_ring_not_closed(it->get_node_ref_stop(), nullptr);
                                 }
                             }
                         }
@@ -939,20 +935,6 @@ namespace osmium {
                     return true;
                 }
 
-                /**
-                 * Checks if any ways were completely removed in the
-                 * erase_duplicate_segments step.
-                 */
-                bool ways_were_lost() {
-                    std::unordered_set<const osmium::Way*> ways_in_segments;
-
-                    for (const auto& segment : m_segment_list) {
-                        ways_in_segments.insert(segment.way());
-                    }
-
-                    return ways_in_segments.size() < m_num_members;
-                }
-
 #ifdef OSMIUM_WITH_TIMER
                 static bool print_header() {
                     std::cout << "nodes outer_rings inner_rings sort dupl intersection locations split simple_case complex_case roles_check\n";
@@ -1022,15 +1004,6 @@ namespace osmium {
                         return false;
                     }
 
-                    // If one or more complete ways was removed because of
-                    // duplicate segments, this isn't a valid area.
-                    if (ways_were_lost()) {
-                        if (debug()) {
-                            std::cerr << "  Complete ways removed because of duplicate segments\n";
-                        }
-                        return false;
-                    }
-
                     if (m_config.debug_level >= 3) {
                         std::cerr << "Sorted de-duplicated segment list:\n";
                         for (const auto& s : m_segment_list) {
@@ -1170,8 +1143,6 @@ namespace osmium {
 #endif
                 }
 
-                ~BasicAssembler() noexcept = default;
-
                 const AssemblerConfig& config() const noexcept {
                     return m_config;
                 }
diff --git a/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp b/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp
index 1e946805cfe..821e914de08 100644
--- a/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstring>
-
 #include <osmium/area/assembler_config.hpp>
 #include <osmium/area/detail/basic_assembler.hpp>
 #include <osmium/area/stats.hpp>
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/osm/tag.hpp>
 
+#include <cstring>
+
 namespace osmium {
 
     namespace area {
@@ -68,7 +68,7 @@ namespace osmium {
                 static void copy_tags_without_type(osmium::builder::AreaBuilder& builder, const osmium::TagList& tags) {
                     osmium::builder::TagListBuilder tl_builder{builder};
                     for (const osmium::Tag& tag : tags) {
-                        if (std::strcmp(tag.key(), "type")) {
+                        if (std::strcmp(tag.key(), "type") != 0) {
                             tl_builder.add_tag(tag.key(), tag.value());
                         }
                     }
diff --git a/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp b/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp
index 8039579b2e6..dc3782dbee1 100644
--- a/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/area/detail/vector.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <iosfwd>
 #include <utility>
 
-#include <osmium/area/detail/vector.hpp>
-#include <osmium/osm/location.hpp>
-#include <osmium/osm/node_ref.hpp>
-
 namespace osmium {
 
     class Way;
@@ -74,20 +74,20 @@ namespace osmium {
             class NodeRefSegment {
 
                 // First node in order described above.
-                osmium::NodeRef m_first;
+                osmium::NodeRef m_first{};
 
                 // Second node in order described above.
-                osmium::NodeRef m_second;
+                osmium::NodeRef m_second{};
 
                 // Way this segment was from.
-                const osmium::Way* m_way;
+                const osmium::Way* m_way = nullptr;
 
                 // The ring this segment is part of. Initially nullptr, this
                 // will be filled in once we know which ring the segment is in.
-                ProtoRing* m_ring;
+                ProtoRing* m_ring = nullptr;
 
                 // The role of this segment from the member role.
-                role_type m_role;
+                role_type m_role = role_type::unknown;
 
                 // Nodes have to be reversed to get the intended order.
                 bool m_reverse = false;
@@ -98,19 +98,12 @@ namespace osmium {
 
             public:
 
-                NodeRefSegment() noexcept :
-                    m_first(),
-                    m_second(),
-                    m_way(nullptr),
-                    m_ring(nullptr),
-                    m_role(role_type::unknown) {
-                }
+                NodeRefSegment() noexcept = default;
 
                 NodeRefSegment(const osmium::NodeRef& nr1, const osmium::NodeRef& nr2, role_type role, const osmium::Way* way) noexcept :
                     m_first(nr1),
                     m_second(nr2),
                     m_way(way),
-                    m_ring(nullptr),
                     m_role(role) {
                     if (nr2.location() < nr1.location()) {
                         using std::swap;
@@ -303,7 +296,7 @@ namespace osmium {
              *          or a defined Location if the segments intersect.
              */
             inline osmium::Location calculate_intersection(const NodeRefSegment& s1, const NodeRefSegment& s2) noexcept {
-                // See http://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
+                // See https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
                 // for some hints about how the algorithm works.
                 const vec p0{s1.first()};
                 const vec p1{s1.second()};
diff --git a/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp b/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp
index 7ab353b882c..6be29f94d72 100644
--- a/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,10 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/area/detail/node_ref_segment.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
@@ -40,10 +44,6 @@ DEALINGS IN THE SOFTWARE.
 #include <set>
 #include <vector>
 
-#include <osmium/osm/location.hpp>
-#include <osmium/osm/node_ref.hpp>
-#include <osmium/area/detail/node_ref_segment.hpp>
-
 namespace osmium {
 
     class Way;
@@ -64,18 +64,18 @@ namespace osmium {
             private:
 
                 // Segments in this ring.
-                segments_type m_segments;
+                segments_type m_segments{};
 
                 // If this is an outer ring, these point to it's inner rings
                 // (if any).
-                std::vector<ProtoRing*> m_inner;
+                std::vector<ProtoRing*> m_inner{};
 
                 // The smallest segment. Will be kept current whenever a new
                 // segment is added to the ring.
                 NodeRefSegment* m_min_segment;
 
                 // If this is an inner ring, points to the outer ring.
-                ProtoRing* m_outer_ring;
+                ProtoRing* m_outer_ring = nullptr;
 
 #ifdef OSMIUM_DEBUG_RING_NO
                 static int64_t next_num() noexcept {
@@ -91,10 +91,7 @@ namespace osmium {
             public:
 
                 explicit ProtoRing(NodeRefSegment* segment) noexcept :
-                    m_segments(),
-                    m_inner(),
                     m_min_segment(segment),
-                    m_outer_ring(nullptr),
 #ifdef OSMIUM_DEBUG_RING_NO
                     m_num(next_num()),
 #endif
diff --git a/third_party/libosmium/include/osmium/area/detail/segment_list.hpp b/third_party/libosmium/include/osmium/area/detail/segment_list.hpp
index 39e16abaeaf..776507b46a9 100644
--- a/third_party/libosmium/include/osmium/area/detail/segment_list.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/segment_list.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/area/detail/node_ref_segment.hpp>
+#include <osmium/area/problem_reporter.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/way.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
@@ -43,15 +52,6 @@ DEALINGS IN THE SOFTWARE.
 #include <unordered_set>
 #include <vector>
 
-#include <osmium/area/detail/node_ref_segment.hpp>
-#include <osmium/area/problem_reporter.hpp>
-#include <osmium/osm/item_type.hpp>
-#include <osmium/osm/location.hpp>
-#include <osmium/osm/node_ref.hpp>
-#include <osmium/osm/relation.hpp>
-#include <osmium/osm/types.hpp>
-#include <osmium/osm/way.hpp>
-
 namespace osmium {
 
     namespace area {
@@ -84,7 +84,7 @@ namespace osmium {
 
                 using slist_type = std::vector<NodeRefSegment>;
 
-                slist_type m_segments;
+                slist_type m_segments{};
 
                 bool m_debug;
 
@@ -144,7 +144,6 @@ namespace osmium {
             public:
 
                 explicit SegmentList(bool debug) noexcept :
-                    m_segments(),
                     m_debug(debug) {
                 }
 
diff --git a/third_party/libosmium/include/osmium/area/detail/vector.hpp b/third_party/libosmium/include/osmium/area/detail/vector.hpp
index e8ff0a501ff..dae6c634739 100644
--- a/third_party/libosmium/include/osmium/area/detail/vector.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/vector.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <iosfwd>
-
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/node_ref.hpp>
 
+#include <cstdint>
+#include <iosfwd>
+
 namespace osmium {
 
     namespace area {
diff --git a/third_party/libosmium/include/osmium/area/geom_assembler.hpp b/third_party/libosmium/include/osmium/area/geom_assembler.hpp
index 8fb3b3ac5dc..4c9fc276ea1 100644
--- a/third_party/libosmium/include/osmium/area/geom_assembler.hpp
+++ b/third_party/libosmium/include/osmium/area/geom_assembler.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp b/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp
index 9ad68e166d2..d57294120fd 100644
--- a/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp
+++ b/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cstddef>
-#include <cstring>
-#include <vector>
-
 #include <osmium/area/stats.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm/item_type.hpp>
@@ -48,6 +43,11 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/way.hpp>
 #include <osmium/relations/collector.hpp>
 
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <vector>
+
 namespace osmium {
 
     namespace relations {
diff --git a/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp b/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp
index e5ee2c8f196..dd3c4d875b7 100644
--- a/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp
+++ b/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,13 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <vector>
-
 #include <osmium/area/stats.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/relation.hpp>
@@ -53,6 +46,13 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/tags/taglist.hpp>
 #include <osmium/tags/tags_filter.hpp>
 
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
 namespace osmium {
 
     /**
@@ -93,9 +93,9 @@ namespace osmium {
              *               needed on closed ways or multipolygon relations
              *               to build the area.
              */
-            explicit MultipolygonManager(const assembler_config_type& assembler_config, const osmium::TagsFilter& filter = osmium::TagsFilter{true}) :
-                m_assembler_config(assembler_config),
-                m_filter(filter) {
+            explicit MultipolygonManager(assembler_config_type assembler_config, osmium::TagsFilter filter = osmium::TagsFilter{true}) :
+                m_assembler_config(std::move(assembler_config)),
+                m_filter(std::move(filter)) {
             }
 
             /**
diff --git a/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp b/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp
index 491557aa8f2..c611d3447f7 100644
--- a/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp
+++ b/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,13 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <vector>
-
 #include <osmium/area/stats.hpp>
 #include <osmium/handler.hpp>
 #include <osmium/handler/check_order.hpp>
@@ -55,6 +48,13 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/relations/relations_manager.hpp>
 #include <osmium/storage/item_stash.hpp>
 
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
 namespace osmium {
 
     /**
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter.hpp b/third_party/libosmium/include/osmium/area/problem_reporter.hpp
index 181d2d1ee64..36f0833fae8 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/types.hpp>
 
+#include <cstddef>
+
 namespace osmium {
 
     class NodeRef;
@@ -62,18 +62,24 @@ namespace osmium {
         protected:
 
             // Type of object we are currently working on
-            osmium::item_type m_object_type;
+            osmium::item_type m_object_type = osmium::item_type::undefined;
 
             // ID of the relation/way we are currently working on
-            osmium::object_id_type m_object_id;
+            osmium::object_id_type m_object_id = 0;
 
             // Number of nodes in the area
-            size_t m_nodes;
+            size_t m_nodes = 0;
 
         public:
 
             ProblemReporter() = default;
 
+            ProblemReporter(const ProblemReporter&) = default;
+            ProblemReporter& operator=(const ProblemReporter&) = default;
+
+            ProblemReporter(ProblemReporter&&) noexcept = default;
+            ProblemReporter& operator=(ProblemReporter&&) noexcept = default;
+
             virtual ~ProblemReporter() = default;
 
             /**
@@ -161,7 +167,7 @@ namespace osmium {
              * @param nr   NodeRef of one end of the ring.
              * @param way  Optional pointer to way the end node is in.
              */
-            virtual void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way = nullptr) {
+            virtual void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way) {
             }
 
             /**
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp b/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp
index cfc2b5428c5..2224f66eaae 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,13 +33,13 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <sstream>
-#include <stdexcept>
-
 #include <osmium/area/problem_reporter_stream.hpp>
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/types.hpp>
 
+#include <sstream>
+#include <stdexcept>
+
 namespace osmium {
 
     class NodeRef;
@@ -57,8 +57,6 @@ namespace osmium {
                 ProblemReporterStream(m_sstream) {
             }
 
-            ~ProblemReporterException() override = default;
-
             void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override {
                 m_sstream.str("");
                 ProblemReporterStream::report_duplicate_node(node_id1, node_id2, location);
@@ -90,7 +88,7 @@ namespace osmium {
                 throw std::runtime_error{m_sstream.str()};
             }
 
-            void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way = nullptr) override {
+            void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way) override {
                 m_sstream.str("");
                 ProblemReporterStream::report_ring_not_closed(nr, way);
                 throw std::runtime_error{m_sstream.str()};
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp b/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp
index 5f531c8f4f3..748cf059c54 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,10 +42,6 @@ DEALINGS IN THE SOFTWARE.
  * @attention If you include this file, you'll need to link with `libgdal`.
  */
 
-#include <memory>
-
-#include <gdalcpp.hpp>
-
 #include <osmium/area/problem_reporter.hpp>
 #include <osmium/geom/factory.hpp>
 #include <osmium/geom/ogr.hpp>
@@ -56,6 +52,10 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 
+#include <gdalcpp.hpp>
+
+#include <memory>
+
 namespace osmium {
 
     namespace area {
@@ -137,8 +137,6 @@ namespace osmium {
                 ;
             }
 
-            ~ProblemReporterOGR() override = default;
-
             void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override {
                 write_point("duplicate_node", node_id1, node_id2, location);
             }
@@ -162,7 +160,7 @@ namespace osmium {
                 write_line("overlapping_segment", nr1.ref(), nr2.ref(), nr1.location(), nr2.location());
             }
 
-            void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way = nullptr) override {
+            void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way) override {
                 write_point("ring_not_closed", nr.ref(), way ? way->id() : 0, nr.location());
             }
 
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp b/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp
index 774e9c3b477..09c48d5dc3d 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,8 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <ostream>
-
 #include <osmium/area/problem_reporter.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
@@ -42,6 +40,8 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 
+#include <ostream>
+
 namespace osmium {
 
     namespace area {
@@ -56,8 +56,6 @@ namespace osmium {
                 m_out(&out) {
             }
 
-            ~ProblemReporterStream() override = default;
-
             void header(const char* msg) {
                 *m_out << "DATA PROBLEM: " << msg << " on " << item_type_to_char(m_object_type) << m_object_id << " (with " << m_nodes << " nodes): ";
             }
@@ -91,7 +89,7 @@ namespace osmium {
                        << " node_id2=" << nr2.ref() << " location2=" << nr2.location() << "\n";
             }
 
-            void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way = nullptr) override {
+            void report_ring_not_closed(const osmium::NodeRef& nr, const osmium::Way* way) override {
                 header("ring not closed");
                 *m_out << "node_id=" << nr.ref() << " location=" << nr.location();
                 if (way) {
diff --git a/third_party/libosmium/include/osmium/area/stats.hpp b/third_party/libosmium/include/osmium/area/stats.hpp
index 6133da8473b..7804111817a 100644
--- a/third_party/libosmium/include/osmium/area/stats.hpp
+++ b/third_party/libosmium/include/osmium/area/stats.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/builder/attr.hpp b/third_party/libosmium/include/osmium/builder/attr.hpp
index bcd48613a62..2dd6239ea88 100644
--- a/third_party/libosmium/include/osmium/builder/attr.hpp
+++ b/third_party/libosmium/include/osmium/builder/attr.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-#include <cstdint>
-#include <ctime>
-#include <initializer_list>
-#include <iterator>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
 #include <osmium/builder/builder.hpp>
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/memory/buffer.hpp>
@@ -56,6 +46,16 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/osm/types.hpp>
 
+#include <cstddef>
+#include <cstdint>
+#include <ctime>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
 namespace osmium {
 
     namespace builder {
@@ -94,13 +94,13 @@ namespace osmium {
             };
 #else
             // True if Predicate matches for none of the types Ts
-            template <template<typename> class Predicate, typename... Ts>
+            template <template <typename> class Predicate, typename... Ts>
             struct static_none_of : std::is_same<std::tuple<std::false_type, typename Predicate<Ts>::type...>,
                                                  std::tuple<typename Predicate<Ts>::type..., std::false_type>>
             {};
 
             // True if Predicate matches for all of the types Ts
-            template <template<typename> class Predicate, typename... Ts>
+            template <template <typename> class Predicate, typename... Ts>
             struct static_all_of : std::is_same<std::tuple<std::true_type, typename Predicate<Ts>::type...>,
                                                 std::tuple<typename Predicate<Ts>::type..., std::true_type>>
             {};
@@ -364,17 +364,21 @@ namespace osmium {
 
             template <typename TTagIterator>
             inline constexpr detail::tags_from_iterator_pair<TTagIterator> _tags(TTagIterator first, TTagIterator last) {
-                return detail::tags_from_iterator_pair<TTagIterator>(first, last);
+                return {first, last};
             }
 
             template <typename TContainer>
             inline detail::tags_from_iterator_pair<typename TContainer::const_iterator> _tags(const TContainer& container) {
-                return detail::tags_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using tag_ilist = std::initializer_list<std::pair<const char*, const char*>>;
             inline detail::tags_from_iterator_pair<tag_ilist::const_iterator> _tags(const tag_ilist& container) {
-                return detail::tags_from_iterator_pair<tag_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
 
@@ -388,22 +392,28 @@ namespace osmium {
 
             template <typename TIdIterator>
             inline constexpr detail::nodes_from_iterator_pair<TIdIterator> _nodes(TIdIterator first, TIdIterator last) {
-                return detail::nodes_from_iterator_pair<TIdIterator>(first, last);
+                return {first, last};
             }
 
             template <typename TContainer>
             inline detail::nodes_from_iterator_pair<typename TContainer::const_iterator> _nodes(const TContainer& container) {
-                return detail::nodes_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using object_id_ilist = std::initializer_list<osmium::object_id_type>;
             inline detail::nodes_from_iterator_pair<object_id_ilist::const_iterator> _nodes(const object_id_ilist& container) {
-                return detail::nodes_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
             inline detail::nodes_from_iterator_pair<node_ref_ilist::const_iterator> _nodes(const node_ref_ilist& container) {
-                return detail::nodes_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
 
@@ -422,17 +432,21 @@ namespace osmium {
 
             template <typename TMemberIterator>
             inline constexpr detail::members_from_iterator_pair<TMemberIterator> _members(TMemberIterator first, TMemberIterator last) {
-                return detail::members_from_iterator_pair<TMemberIterator>(first, last);
+                return {first, last};
             }
 
             template <typename TContainer>
             inline detail::members_from_iterator_pair<typename TContainer::const_iterator> _members(const TContainer& container) {
-                return detail::members_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using member_ilist = std::initializer_list<member_type>;
             inline detail::members_from_iterator_pair<member_ilist::const_iterator> _members(const member_ilist& container) {
-                return detail::members_from_iterator_pair<member_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
 
@@ -450,58 +464,74 @@ namespace osmium {
 
             template <typename TCommentIterator>
             inline constexpr detail::comments_from_iterator_pair<TCommentIterator> _comments(TCommentIterator first, TCommentIterator last) {
-                return detail::comments_from_iterator_pair<TCommentIterator>(first, last);
+                return {first, last};
             }
 
             template <typename TContainer>
             inline detail::comments_from_iterator_pair<typename TContainer::const_iterator> _comments(const TContainer& container) {
-                return detail::comments_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using comment_ilist = std::initializer_list<comment_type>;
             inline detail::comments_from_iterator_pair<comment_ilist::const_iterator> _comments(const comment_ilist& container) {
-                return detail::comments_from_iterator_pair<comment_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
 
             template <typename TIdIterator>
             inline constexpr detail::outer_ring_from_iterator_pair<TIdIterator> _outer_ring(TIdIterator first, TIdIterator last) {
-                return detail::outer_ring_from_iterator_pair<TIdIterator>(first, last);
+                return {first, last};
             }
 
             template <typename TContainer>
             inline detail::outer_ring_from_iterator_pair<typename TContainer::const_iterator> _outer_ring(const TContainer& container) {
-                return detail::outer_ring_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using object_id_ilist = std::initializer_list<osmium::object_id_type>;
             inline detail::outer_ring_from_iterator_pair<object_id_ilist::const_iterator> _outer_ring(const object_id_ilist& container) {
-                return detail::outer_ring_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
             inline detail::outer_ring_from_iterator_pair<node_ref_ilist::const_iterator> _outer_ring(const node_ref_ilist& container) {
-                return detail::outer_ring_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             template <typename TIdIterator>
             inline constexpr detail::inner_ring_from_iterator_pair<TIdIterator> _inner_ring(TIdIterator first, TIdIterator last) {
-                return detail::inner_ring_from_iterator_pair<TIdIterator>(first, last);
+                return {first, last};
             }
 
             template <typename TContainer>
             inline detail::inner_ring_from_iterator_pair<typename TContainer::const_iterator> _inner_ring(const TContainer& container) {
-                return detail::inner_ring_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using object_id_ilist = std::initializer_list<osmium::object_id_type>;
             inline detail::inner_ring_from_iterator_pair<object_id_ilist::const_iterator> _inner_ring(const object_id_ilist& container) {
-                return detail::inner_ring_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
             using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
             inline detail::inner_ring_from_iterator_pair<node_ref_ilist::const_iterator> _inner_ring(const node_ref_ilist& container) {
-                return detail::inner_ring_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
+                using std::begin;
+                using std::end;
+                return {begin(container), end(container)};
             }
 
 
@@ -516,7 +546,7 @@ namespace osmium {
             struct changeset_handler : public entity_handler {
 
                 template <typename TDummy>
-                static void set_value(osmium::Changeset&, const TDummy&) noexcept {
+                static void set_value(osmium::Changeset& /*changeset*/, const TDummy& /*dummy*/) noexcept {
                 }
 
                 static void set_value(osmium::Changeset& changeset, attr::_cid id) noexcept {
@@ -548,7 +578,7 @@ namespace osmium {
             struct object_handler : public entity_handler {
 
                 template <typename TDummy>
-                static void set_value(osmium::OSMObject&, const TDummy&) noexcept {
+                static void set_value(osmium::OSMObject& /*object*/, const TDummy& /*dummy*/) noexcept {
                 }
 
                 static void set_value(osmium::OSMObject& object, attr::_id id) noexcept {
@@ -601,7 +631,7 @@ namespace osmium {
             // ==============================================================
 
             template <typename... TArgs>
-            inline constexpr const char* get_user(const attr::_user& user, const TArgs&...) noexcept {
+            inline constexpr const char* get_user(const attr::_user& user, const TArgs&... /*args*/) noexcept {
                 return user.value;
             }
 
@@ -611,7 +641,7 @@ namespace osmium {
 
             template <typename TFirst, typename... TRest>
             inline constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type
-            get_user(const TFirst&, const TRest&... args) noexcept {
+            get_user(const TFirst& /*first*/, const TRest&... args) noexcept {
                 return get_user(args...);
             }
 
@@ -625,7 +655,7 @@ namespace osmium {
             struct tags_handler {
 
                 template <typename TDummy>
-                static void set_value(TagListBuilder&, const TDummy&) noexcept {
+                static void set_value(TagListBuilder& /*tlb*/, const TDummy& /*dummy*/) noexcept {
                 }
 
                 static void set_value(TagListBuilder& builder, const attr::_tag& tag) {
@@ -644,7 +674,7 @@ namespace osmium {
             struct nodes_handler {
 
                 template <typename TDummy>
-                static void set_value(WayNodeListBuilder&, const TDummy&) noexcept {
+                static void set_value(WayNodeListBuilder& /*wnlb*/, const TDummy& /*dummy*/) noexcept {
                 }
 
                 static void set_value(WayNodeListBuilder& builder, const attr::_node& node_ref) {
@@ -663,7 +693,7 @@ namespace osmium {
             struct members_handler {
 
                 template <typename TDummy>
-                static void set_value(RelationMemberListBuilder&, const TDummy&) noexcept {
+                static void set_value(RelationMemberListBuilder& /*rmlb*/, const TDummy& /*dummy*/) noexcept {
                 }
 
                 static void set_value(RelationMemberListBuilder& builder, const attr::_member& member) {
@@ -682,7 +712,7 @@ namespace osmium {
             struct discussion_handler {
 
                 template <typename TDummy>
-                static void set_value(ChangesetDiscussionBuilder&, const TDummy&) noexcept {
+                static void set_value(ChangesetDiscussionBuilder& /*cdb*/, const TDummy& /*dummy*/) noexcept {
                 }
 
                 static void set_value(ChangesetDiscussionBuilder& builder, const attr::_comment& comment) {
@@ -703,7 +733,7 @@ namespace osmium {
             struct ring_handler {
 
                 template <typename TDummy>
-                static void set_value(AreaBuilder&, const TDummy&) noexcept {
+                static void set_value(AreaBuilder& /*ab*/, const TDummy& /*dummy*/) noexcept {
                 }
 
                 template <typename TIterator>
@@ -728,7 +758,7 @@ namespace osmium {
 
             template <typename TBuilder, typename THandler, typename... TArgs>
             inline typename std::enable_if<!is_handled_by<THandler, TArgs...>::value>::type
-            add_list(osmium::builder::Builder&, const TArgs&...) noexcept {
+            add_list(osmium::builder::Builder& /*parent*/, const TArgs&... /*args*/) noexcept {
             }
 
             template <typename TBuilder, typename THandler, typename... TArgs>
diff --git a/third_party/libosmium/include/osmium/builder/builder.hpp b/third_party/libosmium/include/osmium/builder/builder.hpp
index 4351588d891..ba044370042 100644
--- a/third_party/libosmium/include/osmium/builder/builder.hpp
+++ b/third_party/libosmium/include/osmium/builder/builder.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/item.hpp>
+#include <osmium/util/compatibility.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 
-#include <osmium/memory/buffer.hpp>
-#include <osmium/memory/item.hpp>
-#include <osmium/util/compatibility.hpp>
-
 namespace osmium {
 
     /**
@@ -60,12 +60,6 @@ namespace osmium {
             Builder* m_parent;
             std::size_t m_item_offset;
 
-            Builder(const Builder&) = delete;
-            Builder(Builder&&) = delete;
-
-            Builder& operator=(const Builder&) = delete;
-            Builder& operator=(Builder&&) = delete;
-
         protected:
 
             explicit Builder(osmium::memory::Buffer& buffer, Builder* parent, osmium::memory::item_size_type size) :
@@ -203,6 +197,12 @@ namespace osmium {
 
         public:
 
+            Builder(const Builder&) = delete;
+            Builder(Builder&&) = delete;
+
+            Builder& operator=(const Builder&) = delete;
+            Builder& operator=(Builder&&) = delete;
+
             /// Return the buffer this builder is using.
             osmium::memory::Buffer& buffer() noexcept {
                 return m_buffer;
diff --git a/third_party/libosmium/include/osmium/builder/builder_helper.hpp b/third_party/libosmium/include/osmium/builder/builder_helper.hpp
index a273e50416f..b6c929680ed 100644
--- a/third_party/libosmium/include/osmium/builder/builder_helper.hpp
+++ b/third_party/libosmium/include/osmium/builder/builder_helper.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/util/compatibility.hpp>
+
 #include <cstddef>
-#include <initializer_list>
 #include <functional>
+#include <initializer_list>
 #include <map>
 #include <utility>
 
-#include <osmium/builder/osm_object_builder.hpp>
-#include <osmium/memory/buffer.hpp>
-#include <osmium/util/compatibility.hpp>
-
 namespace osmium {
 
     class NodeRef;
@@ -103,7 +103,7 @@ namespace osmium {
          * @deprecated
          * Use osmium::builder::add_tag_list() instead.
          */
-        OSMIUM_DEPRECATED inline const osmium::TagList& build_tag_list_from_func(osmium::memory::Buffer& buffer, std::function<void(osmium::builder::TagListBuilder&)> func) {
+        OSMIUM_DEPRECATED inline const osmium::TagList& build_tag_list_from_func(osmium::memory::Buffer& buffer, const std::function<void(osmium::builder::TagListBuilder&)>& func) {
             const size_t pos = buffer.committed();
             {
                 osmium::builder::TagListBuilder tl_builder(buffer);
diff --git a/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp b/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp
index 47063140e8c..dce4d1b01ec 100644
--- a/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp
+++ b/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,18 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstddef>
-#include <cstring>
-#include <initializer_list>
-#include <limits>
-#include <new>
-#include <stdexcept>
-#include <string>
-#include <utility>
-
 #include <osmium/builder/builder.hpp>
 #include <osmium/memory/item.hpp>
 #include <osmium/osm/area.hpp>
@@ -60,9 +48,20 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
-#include <osmium/util/cast.hpp>
 #include <osmium/util/compatibility.hpp>
 
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <initializer_list>
+#include <limits>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace memory {
@@ -85,6 +84,12 @@ namespace osmium {
                 new (&item()) TagList{};
             }
 
+            TagListBuilder(const TagListBuilder&) = delete;
+            TagListBuilder& operator=(const TagListBuilder&) = delete;
+
+            TagListBuilder(TagListBuilder&&) = delete;
+            TagListBuilder& operator=(TagListBuilder&&) = delete;
+
             ~TagListBuilder() {
                 add_padding();
             }
@@ -196,6 +201,12 @@ namespace osmium {
                 new (&item()) T{};
             }
 
+            NodeRefListBuilder(const NodeRefListBuilder&) = delete;
+            NodeRefListBuilder& operator=(const NodeRefListBuilder&) = delete;
+
+            NodeRefListBuilder(NodeRefListBuilder&&) = delete;
+            NodeRefListBuilder& operator=(NodeRefListBuilder&&) = delete;
+
             ~NodeRefListBuilder() {
                 add_padding();
             }
@@ -247,6 +258,12 @@ namespace osmium {
                 new (&item()) RelationMemberList{};
             }
 
+            RelationMemberListBuilder(const RelationMemberListBuilder&) = delete;
+            RelationMemberListBuilder& operator=(const RelationMemberListBuilder&) = delete;
+
+            RelationMemberListBuilder(RelationMemberListBuilder&&) = delete;
+            RelationMemberListBuilder& operator=(RelationMemberListBuilder&&) = delete;
+
             ~RelationMemberListBuilder() {
                 add_padding();
             }
@@ -265,7 +282,7 @@ namespace osmium {
              *         osmium::max_osm_string_length
              */
             void add_member(osmium::item_type type, object_id_type ref, const char* role, const std::size_t role_length, const osmium::OSMObject* full_member = nullptr) {
-                osmium::RelationMember* member = reserve_space_for<osmium::RelationMember>();
+                auto* member = reserve_space_for<osmium::RelationMember>();
                 new (member) osmium::RelationMember{ref, type, full_member != nullptr};
                 add_size(sizeof(RelationMember));
                 add_role(*member, role, role_length);
@@ -339,6 +356,12 @@ namespace osmium {
                 new (&item()) ChangesetDiscussion{};
             }
 
+            ChangesetDiscussionBuilder(const ChangesetDiscussionBuilder&) = delete;
+            ChangesetDiscussionBuilder& operator=(const ChangesetDiscussionBuilder&) = delete;
+
+            ChangesetDiscussionBuilder(ChangesetDiscussionBuilder&&) = delete;
+            ChangesetDiscussionBuilder& operator=(ChangesetDiscussionBuilder&&) = delete;
+
             ~ChangesetDiscussionBuilder() {
                 assert(!m_comment && "You have to always call both add_comment() and then add_comment_text() in that order for each comment!");
                 add_padding();
@@ -440,18 +463,25 @@ namespace osmium {
              * Set user name.
              *
              * @param user Pointer to \0-terminated user name.
+             *
+             * @pre @code strlen(user) < 2^16 - 1 @endcode
              */
             TDerived& set_user(const char* user) {
-                return set_user(user, static_cast_with_assert<string_size_type>(std::strlen(user)));
+                const auto len = std::strlen(user);
+                assert(len < std::numeric_limits<string_size_type>::max());
+                return set_user(user, static_cast<string_size_type>(len));
             }
 
             /**
              * Set user name.
              *
              * @param user User name.
+             *
+             * @pre @code user.size() < 2^16 - 1 @endcode
              */
             TDerived& set_user(const std::string& user) {
-                return set_user(user.data(), static_cast_with_assert<string_size_type>(user.size()));
+                assert(user.size() < std::numeric_limits<string_size_type>::max());
+                return set_user(user.data(), static_cast<string_size_type>(user.size()));
             }
 
             /// @deprecated Use set_user(...) instead.
@@ -649,18 +679,25 @@ namespace osmium {
              * Set user name.
              *
              * @param user Pointer to \0-terminated user name.
+             *
+             * @pre @code strlen(user) < 2^16 - 1 @endcode
              */
             ChangesetBuilder& set_user(const char* user) {
-                return set_user(user, static_cast_with_assert<string_size_type>(std::strlen(user)));
+                const auto len = std::strlen(user);
+                assert(len <= std::numeric_limits<string_size_type>::max());
+                return set_user(user, static_cast<string_size_type>(len));
             }
 
             /**
              * Set user name.
              *
              * @param user User name.
+             *
+             * @pre @code user.size() < 2^16 - 1 @endcode
              */
             ChangesetBuilder& set_user(const std::string& user) {
-                return set_user(user.data(), static_cast_with_assert<string_size_type>(user.size()));
+                assert(user.size() < std::numeric_limits<string_size_type>::max());
+                return set_user(user.data(), static_cast<string_size_type>(user.size()));
             }
 
             /// @deprecated Use set_user(...) instead.
diff --git a/third_party/libosmium/include/osmium/diff_handler.hpp b/third_party/libosmium/include/osmium/diff_handler.hpp
index d042edd8ae2..639a5f45f94 100644
--- a/third_party/libosmium/include/osmium/diff_handler.hpp
+++ b/third_party/libosmium/include/osmium/diff_handler.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/diff_iterator.hpp b/third_party/libosmium/include/osmium/diff_iterator.hpp
index c6508588437..0ea5f8445a5 100644
--- a/third_party/libosmium/include/osmium/diff_iterator.hpp
+++ b/third_party/libosmium/include/osmium/diff_iterator.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/diff_object.hpp>
+
 #include <cassert>
 #include <cstddef>
 #include <iterator>
 #include <type_traits>
 #include <utility>
 
-#include <osmium/osm/diff_object.hpp>
-
 namespace osmium {
 
     class OSMObject;
@@ -69,11 +69,11 @@ namespace osmium {
             const bool use_curr_for_prev =                    m_prev->type() != m_curr->type() || m_prev->id() != m_curr->id();
             const bool use_curr_for_next = m_next == m_end || m_next->type() != m_curr->type() || m_next->id() != m_curr->id();
 
-            m_diff = std::move(osmium::DiffObject{
+            m_diff = osmium::DiffObject{
                 *(use_curr_for_prev ? m_curr : m_prev),
                 *m_curr,
                 *(use_curr_for_next ? m_curr : m_next)
-            });
+            };
         }
 
     public:
diff --git a/third_party/libosmium/include/osmium/diff_visitor.hpp b/third_party/libosmium/include/osmium/diff_visitor.hpp
index 7ede0eeb187..1db5ce2957a 100644
--- a/third_party/libosmium/include/osmium/diff_visitor.hpp
+++ b/third_party/libosmium/include/osmium/diff_visitor.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/dynamic_handler.hpp b/third_party/libosmium/include/osmium/dynamic_handler.hpp
index 8e51852c3b4..96906760b2d 100644
--- a/third_party/libosmium/include/osmium/dynamic_handler.hpp
+++ b/third_party/libosmium/include/osmium/dynamic_handler.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/handler.hpp>
+
 #include <memory>
 #include <utility>
 
-#include <osmium/handler.hpp>
-
 namespace osmium {
 
     class Node;
@@ -54,21 +54,29 @@ namespace osmium {
 
             public:
 
+                HandlerWrapperBase() = default;
+
+                HandlerWrapperBase(const HandlerWrapperBase&) = default;
+                HandlerWrapperBase& operator=(const HandlerWrapperBase&) = default;
+
+                HandlerWrapperBase(HandlerWrapperBase&&) noexcept = default;
+                HandlerWrapperBase& operator=(HandlerWrapperBase&&) noexcept = default;
+
                 virtual ~HandlerWrapperBase() = default;
 
-                virtual void node(const osmium::Node&) {
+                virtual void node(const osmium::Node& /*node*/) {
                 }
 
-                virtual void way(const osmium::Way&) {
+                virtual void way(const osmium::Way& /*way*/) {
                 }
 
-                virtual void relation(const osmium::Relation&) {
+                virtual void relation(const osmium::Relation& /*relation*/) {
                 }
 
-                virtual void area(const osmium::Area&) {
+                virtual void area(const osmium::Area& /*area*/) {
                 }
 
-                virtual void changeset(const osmium::Changeset&) {
+                virtual void changeset(const osmium::Changeset& /*changeset*/) {
                 }
 
                 virtual void flush() {
@@ -78,7 +86,7 @@ namespace osmium {
 
 
             // The following uses trick from
-            // http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence
+            // https://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence
             // to either call handler style functions or visitor style operator().
 
 #define OSMIUM_DYNAMIC_HANDLER_DISPATCH(_name_, _type_) \
@@ -98,12 +106,12 @@ auto _name_##_dispatch(THandler& handler, const osmium::_type_& object, long) ->
             OSMIUM_DYNAMIC_HANDLER_DISPATCH(area, Area)
 
             template <typename THandler>
-            auto flush_dispatch(THandler& handler, int) -> decltype(handler.flush(), void()) {
+            auto flush_dispatch(THandler& handler, int /*dispatch*/) -> decltype(handler.flush(), void()) {
                 handler.flush();
             }
 
             template <typename THandler>
-            void flush_dispatch(THandler&, long) {
+            void flush_dispatch(THandler& /*handler*/, long /*dispatch*/) { // NOLINT(google-runtime-int)
             }
 
             template <typename THandler>
diff --git a/third_party/libosmium/include/osmium/experimental/flex_reader.hpp b/third_party/libosmium/include/osmium/experimental/flex_reader.hpp
index 2f66ba456d4..ead9e36b3cf 100644
--- a/third_party/libosmium/include/osmium/experimental/flex_reader.hpp
+++ b/third_party/libosmium/include/osmium/experimental/flex_reader.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <string>
-#include <utility>
-#include <vector>
-
 #include <osmium/area/assembler.hpp>
 #include <osmium/area/multipolygon_collector.hpp>
 #include <osmium/handler/node_locations_for_ways.hpp> // IWYU pragma: keep
@@ -47,6 +43,10 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/entity_bits.hpp>
 #include <osmium/visitor.hpp>
 
+#include <string>
+#include <utility>
+#include <vector>
+
 namespace osmium {
 
     /**
diff --git a/third_party/libosmium/include/osmium/fwd.hpp b/third_party/libosmium/include/osmium/fwd.hpp
index df2bdd9a93d..eede6fbfdee 100644
--- a/third_party/libosmium/include/osmium/fwd.hpp
+++ b/third_party/libosmium/include/osmium/fwd.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/geom/coordinates.hpp b/third_party/libosmium/include/osmium/geom/coordinates.hpp
index 1b244ef2923..f2f926d7173 100644
--- a/third_party/libosmium/include/osmium/geom/coordinates.hpp
+++ b/third_party/libosmium/include/osmium/geom/coordinates.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/location.hpp>
+#include <osmium/util/double.hpp>
+
 #include <cmath>
 #include <iosfwd>
 #include <limits>
 #include <string>
 
-#include <osmium/osm/location.hpp>
-#include <osmium/util/double.hpp>
-
 namespace osmium {
 
     namespace geom {
@@ -70,8 +70,11 @@ namespace osmium {
             /**
              * Create Coordinates from a Location. Will throw
              * osmium::invalid_location if the location is not valid.
+             *
+             * This constructor is not explicit on purpose allowing use of
+             * a Location everywhere a Coordinates object is needed.
              */
-            Coordinates(const osmium::Location& location) :
+            Coordinates(const osmium::Location& location) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
                 x(location.lon()),
                 y(location.lat()) {
             }
@@ -95,9 +98,9 @@ namespace osmium {
              */
             void append_to_string(std::string& s, const char infix, int precision) const {
                 if (valid()) {
-                    osmium::util::double2string(s, x, precision);
+                    osmium::double2string(s, x, precision);
                     s += infix;
-                    osmium::util::double2string(s, y, precision);
+                    osmium::double2string(s, y, precision);
                 } else {
                     s.append("invalid");
                 }
@@ -143,7 +146,7 @@ namespace osmium {
         }
 
         inline bool operator!=(const Coordinates& lhs, const Coordinates& rhs) noexcept {
-            return ! operator==(lhs, rhs);
+            return !(lhs == rhs);
         }
 
         template <typename TChar, typename TTraits>
diff --git a/third_party/libosmium/include/osmium/geom/factory.hpp b/third_party/libosmium/include/osmium/geom/factory.hpp
index 85d0abd4ac1..f878931be96 100644
--- a/third_party/libosmium/include/osmium/geom/factory.hpp
+++ b/third_party/libosmium/include/osmium/geom/factory.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-#include <stdexcept>
-#include <string>
-#include <utility>
-
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/memory/collection.hpp>
 #include <osmium/memory/item.hpp>
@@ -50,6 +45,11 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 
+#include <cstddef>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     /**
@@ -267,7 +267,6 @@ namespace osmium {
                 size_t num_points = 0;
 
                 if (un == use_nodes::unique) {
-                    osmium::Location last_location;
                     switch (dir) {
                         case direction::forward:
                             num_points = fill_linestring_unique(wnl.cbegin(), wnl.cend());
@@ -294,7 +293,7 @@ namespace osmium {
                 return linestring_finish(num_points);
             }
 
-            linestring_type create_linestring(const osmium::Way& way, use_nodes un=use_nodes::unique, direction dir = direction::forward) {
+            linestring_type create_linestring(const osmium::Way& way, use_nodes un = use_nodes::unique, direction dir = direction::forward) {
                 try {
                     return create_linestring(way.nodes(), un, dir);
                 } catch (osmium::geometry_error& e) {
@@ -341,7 +340,6 @@ namespace osmium {
                 size_t num_points = 0;
 
                 if (un == use_nodes::unique) {
-                    osmium::Location last_location;
                     switch (dir) {
                         case direction::forward:
                             num_points = fill_polygon_unique(wnl.cbegin(), wnl.cend());
@@ -368,7 +366,7 @@ namespace osmium {
                 return polygon_finish(num_points);
             }
 
-            polygon_type create_polygon(const osmium::Way& way, use_nodes un=use_nodes::unique, direction dir = direction::forward) {
+            polygon_type create_polygon(const osmium::Way& way, use_nodes un = use_nodes::unique, direction dir = direction::forward) {
                 try {
                     return create_polygon(way.nodes(), un, dir);
                 } catch (osmium::geometry_error& e) {
diff --git a/third_party/libosmium/include/osmium/geom/geojson.hpp b/third_party/libosmium/include/osmium/geom/geojson.hpp
index e05deba443e..2b5218b1b03 100644
--- a/third_party/libosmium/include/osmium/geom/geojson.hpp
+++ b/third_party/libosmium/include/osmium/geom/geojson.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+
 #include <cassert>
 #include <cstddef>
 #include <string>
 #include <utility>
 
-#include <osmium/geom/coordinates.hpp>
-#include <osmium/geom/factory.hpp>
-
 namespace osmium {
 
     namespace geom {
@@ -60,7 +60,7 @@ namespace osmium {
                 using multipolygon_type = std::string;
                 using ring_type         = std::string;
 
-                GeoJSONFactoryImpl(int /* srid */, int precision = 7) :
+                explicit GeoJSONFactoryImpl(int /*srid*/, int precision = 7) :
                     m_precision(precision) {
                 }
 
@@ -68,7 +68,7 @@ namespace osmium {
 
                 // { "type": "Point", "coordinates": [100.0, 0.0] }
                 point_type make_point(const osmium::geom::Coordinates& xy) const {
-                    std::string str {"{\"type\":\"Point\",\"coordinates\":"};
+                    std::string str{"{\"type\":\"Point\",\"coordinates\":"};
                     xy.append_to_string(str, '[', ',', ']', m_precision);
                     str += "}";
                     return str;
@@ -86,7 +86,7 @@ namespace osmium {
                     m_str += ',';
                 }
 
-                linestring_type linestring_finish(size_t /* num_points */) {
+                linestring_type linestring_finish(size_t /*num_points*/) {
                     assert(!m_str.empty());
                     std::string str;
 
@@ -98,6 +98,28 @@ namespace osmium {
                     return str;
                 }
 
+                /* Polygon */
+                void polygon_start() {
+                    m_str = "{\"type\":\"Polygon\",\"coordinates\":[[";
+                }
+
+                void polygon_add_location(const osmium::geom::Coordinates& xy) {
+                    xy.append_to_string(m_str, '[', ',', ']', m_precision);
+                    m_str += ',';
+                }
+
+                polygon_type polygon_finish(size_t /*num_points*/) {
+                    assert(!m_str.empty());
+                    std::string str;
+
+                    using std::swap;
+                    swap(str, m_str);
+
+                    str.back() = ']';
+                    str += "]}";
+                    return str;
+                }
+
                 /* MultiPolygon */
 
                 void multipolygon_start() {
diff --git a/third_party/libosmium/include/osmium/geom/geos.hpp b/third_party/libosmium/include/osmium/geom/geos.hpp
index 2367b9761eb..c1daa86180f 100644
--- a/third_party/libosmium/include/osmium/geom/geos.hpp
+++ b/third_party/libosmium/include/osmium/geom/geos.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -52,14 +52,9 @@ DEALINGS IN THE SOFTWARE.
  * @attention If you include this file, you'll need to link with `libgeos`.
  */
 
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <iterator>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+#include <osmium/util/compatibility.hpp>
 
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/CoordinateSequence.h>
@@ -72,9 +67,14 @@ DEALINGS IN THE SOFTWARE.
 #include <geos/geom/PrecisionModel.h>
 #include <geos/util/GEOSException.h>
 
-#include <osmium/geom/factory.hpp>
-#include <osmium/geom/coordinates.hpp>
-#include <osmium/util/compatibility.hpp>
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 // MSVC doesn't support throw_with_nested yet
 #ifdef _MSC_VER
diff --git a/third_party/libosmium/include/osmium/geom/haversine.hpp b/third_party/libosmium/include/osmium/geom/haversine.hpp
index 6be72d2e5ba..46cc3085011 100644
--- a/third_party/libosmium/include/osmium/geom/haversine.hpp
+++ b/third_party/libosmium/include/osmium/geom/haversine.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cmath>
-#include <iterator>
-
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/util.hpp>
 #include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/way.hpp>
 
+#include <cmath>
+#include <iterator>
+
 namespace osmium {
 
     namespace geom {
@@ -48,7 +48,7 @@ namespace osmium {
         /**
          * @brief Functions to calculate arc distance on Earth using the haversine formula.
          *
-         * See http://en.wikipedia.org/wiki/Haversine_formula
+         * See https://en.wikipedia.org/wiki/Haversine_formula
          *
          * Implementation derived from
          * http://blog.julien.cayzac.name/2008/10/arc-and-distance-between-two-points-on.html
@@ -69,7 +69,7 @@ namespace osmium {
                 double lath = sin(deg_to_rad(c1.y - c2.y) * 0.5);
                 lath *= lath;
                 const double tmp = cos(deg_to_rad(c1.y)) * cos(deg_to_rad(c2.y));
-                return 2.0 * EARTH_RADIUS_IN_METERS * asin(sqrt(lath + tmp*lonh));
+                return 2.0 * EARTH_RADIUS_IN_METERS * asin(sqrt(lath + tmp * lonh));
             }
 
             /**
diff --git a/third_party/libosmium/include/osmium/geom/mercator_projection.hpp b/third_party/libosmium/include/osmium/geom/mercator_projection.hpp
index 5be84a4653d..febb372acfd 100644
--- a/third_party/libosmium/include/osmium/geom/mercator_projection.hpp
+++ b/third_party/libosmium/include/osmium/geom/mercator_projection.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,13 +33,13 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cmath>
-#include <string>
-
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/util.hpp>
 #include <osmium/osm/location.hpp>
 
+#include <cmath>
+#include <string>
+
 namespace osmium {
 
     namespace geom {
@@ -54,7 +54,7 @@ namespace osmium {
             }
 
             inline double lat_to_y_with_tan(double lat) { // not constexpr because math functions aren't
-                return earth_radius_for_epsg3857 * std::log(std::tan(osmium::geom::PI/4 + deg_to_rad(lat)/2));
+                return earth_radius_for_epsg3857 * std::log(std::tan(osmium::geom::PI / 4 + deg_to_rad(lat) / 2));
             }
 
 #ifdef OSMIUM_USE_SLOW_MERCATOR_PROJECTION
@@ -101,7 +101,7 @@ namespace osmium {
             }
 
             inline double y_to_lat(double y) { // not constexpr because math functions aren't
-                return rad_to_deg(2 * std::atan(std::exp(y / earth_radius_for_epsg3857)) - osmium::geom::PI/2);
+                return rad_to_deg(2 * std::atan(std::exp(y / earth_radius_for_epsg3857)) - osmium::geom::PI / 2);
             }
 
         } // namespace detail
@@ -138,7 +138,11 @@ namespace osmium {
 
         public:
 
-            MercatorProjection() {
+            // This is not "= default" on purpose because some compilers don't
+            // like it and complain that "default initialization of an object
+            // of const type 'const osmium::geom::MercatorProjection' requires
+            // a user-provided default constructor".
+            MercatorProjection() { // NOLINT(hicpp-use-equals-default, modernize-use-equals-default)
             }
 
             Coordinates operator()(osmium::Location location) const {
diff --git a/third_party/libosmium/include/osmium/geom/ogr.hpp b/third_party/libosmium/include/osmium/geom/ogr.hpp
index 3574cdc3aad..73276c1f089 100644
--- a/third_party/libosmium/include/osmium/geom/ogr.hpp
+++ b/third_party/libosmium/include/osmium/geom/ogr.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,16 +42,16 @@ DEALINGS IN THE SOFTWARE.
  * @attention If you include this file, you'll need to link with `libgdal`.
  */
 
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+
+#include <ogr_geometry.h>
+
 #include <cassert>
 #include <cstddef>
 #include <memory>
 #include <utility>
 
-#include <ogr_geometry.h>
-
-#include <osmium/geom/coordinates.hpp>
-#include <osmium/geom/factory.hpp>
-
 namespace osmium {
 
     namespace geom {
diff --git a/third_party/libosmium/include/osmium/geom/projection.hpp b/third_party/libosmium/include/osmium/geom/projection.hpp
index de3bf900340..4b66297095c 100644
--- a/third_party/libosmium/include/osmium/geom/projection.hpp
+++ b/third_party/libosmium/include/osmium/geom/projection.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,16 +42,16 @@ DEALINGS IN THE SOFTWARE.
  * @attention If you include this file, you'll need to link with `libproj`.
  */
 
-#include <memory>
-#include <string>
-
-#include <proj_api.h>
-
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/mercator_projection.hpp>
 #include <osmium/geom/util.hpp>
 #include <osmium/osm/location.hpp>
 
+#include <proj_api.h>
+
+#include <memory>
+#include <string>
+
 namespace osmium {
 
     namespace geom {
@@ -161,7 +161,9 @@ namespace osmium {
             Coordinates operator()(osmium::Location location) const {
                 if (m_epsg == 4326) {
                     return Coordinates{location.lon(), location.lat()};
-                } else if (m_epsg == 3857) {
+                }
+
+                if (m_epsg == 3857) {
                     return Coordinates{detail::lon_to_x(location.lon()),
                                        detail::lat_to_y(location.lat())};
                 }
diff --git a/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp b/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp
index 897d6c3a1dc..53fc79847a1 100644
--- a/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp
+++ b/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/factory.hpp>
 
+#include <cstddef>
+
 namespace osmium {
 
     namespace geom {
diff --git a/third_party/libosmium/include/osmium/geom/relations.hpp b/third_party/libosmium/include/osmium/geom/relations.hpp
index c8d5caf83f5..c3b28c4dde5 100644
--- a/third_party/libosmium/include/osmium/geom/relations.hpp
+++ b/third_party/libosmium/include/osmium/geom/relations.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/geom/tile.hpp b/third_party/libosmium/include/osmium/geom/tile.hpp
index 6f07d8c7294..133916e648c 100644
--- a/third_party/libosmium/include/osmium/geom/tile.hpp
+++ b/third_party/libosmium/include/osmium/geom/tile.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,13 +33,13 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cstdint>
-
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/mercator_projection.hpp>
 #include <osmium/osm/location.hpp>
 
+#include <cassert>
+#include <cstdint>
+
 namespace osmium {
 
     namespace geom {
@@ -177,7 +177,7 @@ namespace osmium {
         }
 
         inline bool operator!=(const Tile& lhs, const Tile& rhs) noexcept {
-            return ! (lhs == rhs);
+            return !(lhs == rhs);
         }
 
         /**
diff --git a/third_party/libosmium/include/osmium/geom/util.hpp b/third_party/libosmium/include/osmium/geom/util.hpp
index 90a705ac1da..6984edf499e 100644
--- a/third_party/libosmium/include/osmium/geom/util.hpp
+++ b/third_party/libosmium/include/osmium/geom/util.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/geom/wkb.hpp b/third_party/libosmium/include/osmium/geom/wkb.hpp
index 5299d458774..405d92defd7 100644
--- a/third_party/libosmium/include/osmium/geom/wkb.hpp
+++ b/third_party/libosmium/include/osmium/geom/wkb.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <string>
-
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/factory.hpp>
 #include <osmium/util/cast.hpp>
 #include <osmium/util/endian.hpp>
 
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
 namespace osmium {
 
     namespace geom {
@@ -70,8 +70,8 @@ namespace osmium {
                 out.reserve(str.size() * 2);
 
                 for (char c : str) {
-                    out += lookup_hex[(c >> 4) & 0xf];
-                    out += lookup_hex[c & 0xf];
+                    out += lookup_hex[(static_cast<unsigned int>(c) >> 4u) & 0xfu];
+                    out += lookup_hex[ static_cast<unsigned int>(c)        & 0xfu];
                 }
 
                 return out;
@@ -83,7 +83,7 @@ namespace osmium {
                 * Type of WKB geometry.
                 * These definitions are from
                 * 99-049_OpenGIS_Simple_Features_Specification_For_SQL_Rev_1.1.pdf (for WKB)
-                * and http://trac.osgeo.org/postgis/browser/trunk/doc/ZMSgeoms.txt (for EWKB).
+                * and https://trac.osgeo.org/postgis/browser/trunk/doc/ZMSgeoms.txt (for EWKB).
                 * They are used to encode geometries into the WKB format.
                 */
                 enum wkbGeometryType : uint32_t {
@@ -140,8 +140,11 @@ namespace osmium {
                 }
 
                 void set_size(const std::size_t offset, const std::size_t size) {
-                    uint32_t s = static_cast_with_assert<uint32_t>(size);
-                    std::copy_n(reinterpret_cast<char*>(&s), sizeof(uint32_t), &m_data[offset]);
+                    if (size > std::numeric_limits<uint32_t>::max()) {
+                        throw geometry_error{"Too many points in geometry"};
+                    }
+                    const auto s = static_cast<uint32_t>(size);
+                    std::copy_n(reinterpret_cast<const char*>(&s), sizeof(uint32_t), &m_data[offset]);
                 }
 
             public:
@@ -168,9 +171,9 @@ namespace osmium {
 
                     if (m_out_type == out_type::hex) {
                         return convert_to_hex(data);
-                    } else {
-                        return data;
                     }
+
+                    return data;
                 }
 
                 /* LineString */
@@ -194,9 +197,9 @@ namespace osmium {
 
                     if (m_out_type == out_type::hex) {
                         return convert_to_hex(data);
-                    } else {
-                        return data;
                     }
+
+                    return data;
                 }
 
                 /* MultiPolygon */
@@ -254,9 +257,9 @@ namespace osmium {
 
                     if (m_out_type == out_type::hex) {
                         return convert_to_hex(data);
-                    } else {
-                        return data;
                     }
+
+                    return data;
                 }
 
             }; // class WKBFactoryImpl
diff --git a/third_party/libosmium/include/osmium/geom/wkt.hpp b/third_party/libosmium/include/osmium/geom/wkt.hpp
index 96a5168ba05..5801c652b62 100644
--- a/third_party/libosmium/include/osmium/geom/wkt.hpp
+++ b/third_party/libosmium/include/osmium/geom/wkt.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+
 #include <cassert>
 #include <cstddef>
 #include <string>
 #include <utility>
 
-#include <osmium/geom/coordinates.hpp>
-#include <osmium/geom/factory.hpp>
-
 namespace osmium {
 
     namespace geom {
@@ -67,8 +67,7 @@ namespace osmium {
                 using multipolygon_type = std::string;
                 using ring_type         = std::string;
 
-                WKTFactoryImpl(int srid, int precision = 7, wkt_type wtype = wkt_type::wkt) :
-                    m_srid_prefix(),
+                explicit WKTFactoryImpl(int srid, int precision = 7, wkt_type wtype = wkt_type::wkt) :
                     m_precision(precision),
                     m_wkt_type(wtype) {
                     if (m_wkt_type == wkt_type::ewkt) {
@@ -81,7 +80,7 @@ namespace osmium {
                 /* Point */
 
                 point_type make_point(const osmium::geom::Coordinates& xy) const {
-                    std::string str {m_srid_prefix};
+                    std::string str{m_srid_prefix};
                     str += "POINT";
                     xy.append_to_string(str, '(', ' ', ')', m_precision);
                     return str;
@@ -110,6 +109,29 @@ namespace osmium {
                     return str;
                 }
 
+                /* Polygon */
+                void polygon_start() {
+                    m_str = m_srid_prefix;
+                    m_str += "POLYGON((";
+                }
+
+                void polygon_add_location(const osmium::geom::Coordinates& xy) {
+                    xy.append_to_string(m_str, ' ', m_precision);
+                    m_str += ',';
+                }
+
+                polygon_type polygon_finish(size_t /* num_points */) {
+                    assert(!m_str.empty());
+                    std::string str;
+
+                    using std::swap;
+                    swap(str, m_str);
+
+                    str.back() = ')';
+                    str += ")";
+                    return str;
+                }
+
                 /* MultiPolygon */
 
                 void multipolygon_start() {
diff --git a/third_party/libosmium/include/osmium/handler.hpp b/third_party/libosmium/include/osmium/handler.hpp
index a1643911571..fe9dca3f430 100644
--- a/third_party/libosmium/include/osmium/handler.hpp
+++ b/third_party/libosmium/include/osmium/handler.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -72,40 +72,40 @@ namespace osmium {
 
         public:
 
-            void osm_object(const osmium::OSMObject&) const noexcept {
+            void osm_object(const osmium::OSMObject& /*osm_object*/) const noexcept {
             }
 
-            void node(const osmium::Node&) const noexcept {
+            void node(const osmium::Node& /*node*/) const noexcept {
             }
 
-            void way(const osmium::Way&) const noexcept {
+            void way(const osmium::Way& /*way*/) const noexcept {
             }
 
-            void relation(const osmium::Relation&) const noexcept {
+            void relation(const osmium::Relation& /*relation*/) const noexcept {
             }
 
-            void area(const osmium::Area&) const noexcept {
+            void area(const osmium::Area& /*area*/) const noexcept {
             }
 
-            void changeset(const osmium::Changeset&) const noexcept {
+            void changeset(const osmium::Changeset& /*changeset*/) const noexcept {
             }
 
-            void tag_list(const osmium::TagList&) const noexcept {
+            void tag_list(const osmium::TagList& /*tag_list*/) const noexcept {
             }
 
-            void way_node_list(const osmium::WayNodeList&) const noexcept {
+            void way_node_list(const osmium::WayNodeList& /*way_node_list*/) const noexcept {
             }
 
-            void relation_member_list(const osmium::RelationMemberList&) const noexcept {
+            void relation_member_list(const osmium::RelationMemberList& /*relation_member_list*/) const noexcept {
             }
 
-            void outer_ring(const osmium::OuterRing&) const noexcept {
+            void outer_ring(const osmium::OuterRing& /*outer_ring*/) const noexcept {
             }
 
-            void inner_ring(const osmium::InnerRing&) const noexcept {
+            void inner_ring(const osmium::InnerRing& /*inner_ring*/) const noexcept {
             }
 
-            void changeset_discussion(const osmium::ChangesetDiscussion&) const noexcept {
+            void changeset_discussion(const osmium::ChangesetDiscussion& /*changeset_discussion*/) const noexcept {
             }
 
             void flush() const noexcept {
diff --git a/third_party/libosmium/include/osmium/handler/chain.hpp b/third_party/libosmium/include/osmium/handler/chain.hpp
index 2ab9d292ca7..5f4bb78e759 100644
--- a/third_party/libosmium/include/osmium/handler/chain.hpp
+++ b/third_party/libosmium/include/osmium/handler/chain.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,10 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <tuple>
-
 #include <osmium/handler.hpp>
 
+#include <tuple>
+
 #define OSMIUM_CHAIN_HANDLER_CALL(_func_, _type_) \
     template <int N, int SIZE, typename THandlers> \
     struct call_ ## _func_ { \
diff --git a/third_party/libosmium/include/osmium/handler/check_order.hpp b/third_party/libosmium/include/osmium/handler/check_order.hpp
index 48a673b744d..c6d77bbaf4d 100644
--- a/third_party/libosmium/include/osmium/handler/check_order.hpp
+++ b/third_party/libosmium/include/osmium/handler/check_order.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <limits>
-#include <stdexcept>
-#include <string>
-
 #include <osmium/handler.hpp>
 #include <osmium/osm/node.hpp>
 #include <osmium/osm/object_comparisons.hpp>
@@ -44,6 +40,10 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 
+#include <limits>
+#include <stdexcept>
+#include <string>
+
 namespace osmium {
 
     /**
diff --git a/third_party/libosmium/include/osmium/handler/disk_store.hpp b/third_party/libosmium/include/osmium/handler/disk_store.hpp
index da1119dde91..8ec4c3ecc02 100644
--- a/third_party/libosmium/include/osmium/handler/disk_store.hpp
+++ b/third_party/libosmium/include/osmium/handler/disk_store.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,8 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-
 #include <osmium/handler.hpp>
 #include <osmium/index/map.hpp>
 #include <osmium/io/detail/read_write.hpp>
@@ -46,6 +44,8 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/way.hpp>
 #include <osmium/visitor.hpp>
 
+#include <cstddef>
+
 namespace osmium {
 
     namespace handler {
@@ -78,11 +78,6 @@ namespace osmium {
                 m_relation_index(relation_index) {
             }
 
-            DiskStore(const DiskStore&) = delete;
-            DiskStore& operator=(const DiskStore&) = delete;
-
-            ~DiskStore() noexcept = default;
-
             void node(const osmium::Node& node) {
                 m_node_index.set(node.positive_id(), m_offset);
                 m_offset += node.byte_size();
diff --git a/third_party/libosmium/include/osmium/handler/dump.hpp b/third_party/libosmium/include/osmium/handler/dump.hpp
index 9c2c5c66e31..8827387b65a 100644
--- a/third_party/libosmium/include/osmium/handler/dump.hpp
+++ b/third_party/libosmium/include/osmium/handler/dump.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <iomanip>
-#include <iostream>
-#include <string>
-
 #include <osmium/handler.hpp>
 #include <osmium/memory/collection.hpp>
 #include <osmium/memory/item.hpp>
@@ -54,6 +50,10 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/way.hpp>
 #include <osmium/visitor.hpp>
 
+#include <iomanip>
+#include <iostream>
+#include <string>
+
 namespace osmium {
 
     namespace handler {
@@ -136,10 +136,10 @@ namespace osmium {
 
         public:
 
-            explicit Dump(std::ostream& out, bool with_size = true, const std::string& prefix = "") :
+            explicit Dump(std::ostream& out, bool with_size = true, std::string prefix = "") :
                 m_out(&out),
                 m_with_size(with_size),
-                m_prefix(prefix) {
+                m_prefix(std::move(prefix)) {
             }
 
             void tag_list(const osmium::TagList& tags) {
diff --git a/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp b/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp
index ff3fbe9c9eb..640b7016fad 100644
--- a/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp
+++ b/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,19 +33,18 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <limits>
-#include <type_traits>
-
 #include <osmium/handler.hpp>
 #include <osmium/index/index.hpp>
 #include <osmium/index/map/dummy.hpp>
+#include <osmium/index/node_locations_map.hpp>
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/node.hpp>
 #include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 
-#include <osmium/index/node_locations_map.hpp>
+#include <limits>
+#include <type_traits>
 
 namespace osmium {
 
@@ -99,7 +98,7 @@ namespace osmium {
         public:
 
             explicit NodeLocationsForWays(TStoragePosIDs& storage_pos,
-                                          TStorageNegIDs& storage_neg = get_dummy()) :
+                                          TStorageNegIDs& storage_neg = get_dummy()) noexcept :
                 m_storage_pos(storage_pos),
                 m_storage_neg(storage_neg) {
             }
@@ -107,8 +106,8 @@ namespace osmium {
             NodeLocationsForWays(const NodeLocationsForWays&) = delete;
             NodeLocationsForWays& operator=(const NodeLocationsForWays&) = delete;
 
-            NodeLocationsForWays(NodeLocationsForWays&&) = default;
-            NodeLocationsForWays& operator=(NodeLocationsForWays&&) = default;
+            NodeLocationsForWays(NodeLocationsForWays&&) noexcept = default;
+            NodeLocationsForWays& operator=(NodeLocationsForWays&&) noexcept = default;
 
             ~NodeLocationsForWays() noexcept = default;
 
@@ -138,10 +137,9 @@ namespace osmium {
              */
             osmium::Location get_node_location(const osmium::object_id_type id) const {
                 if (id >= 0) {
-                    return m_storage_pos.get_noexcept(static_cast<osmium::unsigned_object_id_type>( id));
-                } else {
-                    return m_storage_neg.get_noexcept(static_cast<osmium::unsigned_object_id_type>(-id));
+                    return m_storage_pos.get_noexcept(static_cast<osmium::unsigned_object_id_type>(id));
                 }
+                return m_storage_neg.get_noexcept(static_cast<osmium::unsigned_object_id_type>(-id));
             }
 
             /**
diff --git a/third_party/libosmium/include/osmium/handler/object_relations.hpp b/third_party/libosmium/include/osmium/handler/object_relations.hpp
index c99e1bcb21b..fd903ea22e1 100644
--- a/third_party/libosmium/include/osmium/handler/object_relations.hpp
+++ b/third_party/libosmium/include/osmium/handler/object_relations.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -35,8 +35,8 @@ DEALINGS IN THE SOFTWARE.
 
 #include <osmium/handler.hpp>
 #include <osmium/index/multimap.hpp>
-#include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/item_type.hpp>
+#include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/relation.hpp>
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
@@ -70,11 +70,6 @@ namespace osmium {
                 m_index_r2r(r2r) {
             }
 
-            ObjectRelations(const ObjectRelations&) = delete;
-            ObjectRelations& operator=(const ObjectRelations&) = delete;
-
-            ~ObjectRelations() noexcept = default;
-
             void way(const osmium::Way& way) {
                 for (const auto& node_ref : way.nodes()) {
                     m_index_n2w.set(node_ref.positive_ref(), way.positive_id());
diff --git a/third_party/libosmium/include/osmium/index/bool_vector.hpp b/third_party/libosmium/include/osmium/index/bool_vector.hpp
index 9c99adef54b..11290d6567d 100644
--- a/third_party/libosmium/include/osmium/index/bool_vector.hpp
+++ b/third_party/libosmium/include/osmium/index/bool_vector.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp b/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp
index 745a3580576..32a9b63173b 100644
--- a/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -54,7 +54,7 @@ namespace osmium {
                 }
                 assert(config.size() > 1);
                 const std::string& filename = config[1];
-                const int fd = ::open(filename.c_str(), O_CREAT | O_RDWR, 0644);
+                const int fd = ::open(filename.c_str(), O_CREAT | O_RDWR, 0644); // NOLINT(hicpp-signed-bitwise)
                 if (fd == -1) {
                     throw std::runtime_error{std::string{"can't open file '"} + filename + "': " + std::strerror(errno)};
                 }
diff --git a/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp b/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp
index 1192d8f34ee..555246dc5a4 100644
--- a/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -54,8 +54,6 @@ namespace osmium {
                 mmap_vector_base<T>() {
             }
 
-            ~mmap_vector_anon() noexcept = default;
-
         }; // class mmap_vector_anon
 
     } // namespace detail
diff --git a/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp b/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp
index 6cf64062fa2..6e0bbf42d82 100644
--- a/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/index/index.hpp>
+#include <osmium/util/memory_mapping.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <new> // IWYU pragma: keep
 #include <stdexcept>
 
-#include <osmium/index/index.hpp>
-#include <osmium/util/memory_mapping.hpp>
-
 namespace osmium {
 
     namespace detail {
@@ -58,27 +58,24 @@ namespace osmium {
 
         protected:
 
-            size_t m_size;
-            osmium::util::TypedMemoryMapping<T> m_mapping;
+            size_t m_size = 0;
+            osmium::TypedMemoryMapping<T> m_mapping;
 
         public:
 
             mmap_vector_base(int fd, size_t capacity, size_t size = 0) :
                 m_size(size),
-                m_mapping(capacity, osmium::util::MemoryMapping::mapping_mode::write_shared, fd) {
+                m_mapping(capacity, osmium::MemoryMapping::mapping_mode::write_shared, fd) {
                 assert(size <= capacity);
                 std::fill(data() + size, data() + capacity, osmium::index::empty_value<T>());
                 shrink_to_fit();
             }
 
             explicit mmap_vector_base(size_t capacity = mmap_vector_size_increment) :
-                m_size(0),
                 m_mapping(capacity) {
                 std::fill_n(data(), capacity, osmium::index::empty_value<T>());
             }
 
-            ~mmap_vector_base() noexcept = default;
-
             using value_type      = T;
             using pointer         = value_type*;
             using const_pointer   = const value_type*;
diff --git a/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp b/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp
index d853992a483..8258bb37464 100644
--- a/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/index/detail/mmap_vector_base.hpp>
+#include <osmium/index/detail/tmpfile.hpp>
+#include <osmium/util/file.hpp>
+
 #include <algorithm>
 #include <cstddef>
 #include <stdexcept>
 #include <string>
 
-#include <osmium/index/detail/mmap_vector_base.hpp>
-#include <osmium/index/detail/tmpfile.hpp>
-#include <osmium/util/file.hpp>
-
 namespace osmium {
 
     namespace detail {
@@ -54,7 +54,7 @@ namespace osmium {
         class mmap_vector_file : public mmap_vector_base<T> {
 
             static std::size_t filesize(int fd) {
-                const auto size = osmium::util::file_size(fd);
+                const auto size = osmium::file_size(fd);
 
                 if (size % sizeof(T) != 0) {
                     throw std::runtime_error{"Index file has wrong size (must be multiple of " + std::to_string(sizeof(T)) + ")."};
@@ -78,8 +78,6 @@ namespace osmium {
                     filesize(fd)) {
             }
 
-            ~mmap_vector_file() noexcept = default;
-
         }; // class mmap_vector_file
 
     } // namespace detail
diff --git a/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp b/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp
index ce9b194d58b..26a39de15e0 100644
--- a/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/detail/vector_map.hpp b/third_party/libosmium/include/osmium/index/detail/vector_map.hpp
index 0eb49d59671..c560ed91eb2 100644
--- a/third_party/libosmium/include/osmium/index/detail/vector_map.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/vector_map.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cstddef>
-#include <utility>
-
 #include <osmium/index/index.hpp>
 #include <osmium/index/map.hpp>
 #include <osmium/io/detail/read_write.hpp>
 
+#include <algorithm>
+#include <cstddef>
+#include <utility>
+
 namespace osmium {
 
     namespace index {
@@ -67,8 +67,6 @@ namespace osmium {
                     m_vector(fd) {
                 }
 
-                ~VectorBasedDenseMap() noexcept final = default;
-
                 void reserve(const std::size_t size) final {
                     m_vector.reserve(size);
                 }
@@ -146,7 +144,7 @@ namespace osmium {
             }; // class VectorBasedDenseMap
 
 
-            template <typename TId, typename TValue, template<typename...> class TVector>
+            template <typename TId, typename TValue, template <typename...> class TVector>
             class VectorBasedSparseMap : public Map<TId, TValue> {
 
             public:
@@ -180,8 +178,6 @@ namespace osmium {
                     m_vector(fd) {
                 }
 
-                ~VectorBasedSparseMap() final = default;
-
                 void set(const TId id, const TValue value) final {
                     m_vector.push_back(element_type(id, value));
                 }
diff --git a/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp b/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp
index b0151233b65..b7fdf84db7f 100644
--- a/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,21 +33,21 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cstddef>
-#include <utility>
-
 #include <osmium/index/index.hpp>
 #include <osmium/index/multimap.hpp>
 #include <osmium/io/detail/read_write.hpp>
 
+#include <algorithm>
+#include <cstddef>
+#include <utility>
+
 namespace osmium {
 
     namespace index {
 
         namespace multimap {
 
-            template <typename TId, typename TValue, template<typename...> class TVector>
+            template <typename TId, typename TValue, template <typename...> class TVector>
             class VectorBasedSparseMultimap : public Multimap<TId, TValue> {
 
             public:
@@ -75,8 +75,6 @@ namespace osmium {
                     m_vector(fd) {
                 }
 
-                ~VectorBasedSparseMultimap() noexcept final = default;
-
                 void set(const TId id, const TValue value) final {
                     m_vector.push_back(element_type(id, value));
                 }
diff --git a/third_party/libosmium/include/osmium/index/id_set.hpp b/third_party/libosmium/include/osmium/index/id_set.hpp
index d86973d8587..eefdf821c31 100644
--- a/third_party/libosmium/include/osmium/index/id_set.hpp
+++ b/third_party/libosmium/include/osmium/index/id_set.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,9 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/types.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -42,9 +45,6 @@ DEALINGS IN THE SOFTWARE.
 #include <type_traits>
 #include <vector>
 
-#include <osmium/osm/item_type.hpp>
-#include <osmium/osm/types.hpp>
-
 namespace osmium {
 
     namespace index {
@@ -58,6 +58,14 @@ namespace osmium {
 
         public:
 
+            IdSet() = default;
+
+            IdSet(const IdSet&) = default;
+            IdSet& operator=(const IdSet&) = default;
+
+            IdSet(IdSet&&) noexcept = default;
+            IdSet& operator=(IdSet&&) noexcept = default;
+
             virtual ~IdSet() = default;
 
             /**
@@ -113,7 +121,7 @@ namespace osmium {
                         const auto slot = m_set->m_data[cid][IdSetDense<T>::offset(m_value)];
                         if (slot == 0) {
                             m_value += 8;
-                            m_value &= ~0x7;
+                            m_value &= ~0x7ull;
                         } else {
                             ++m_value;
                         }
@@ -154,7 +162,7 @@ namespace osmium {
             }
 
             bool operator!=(const IdSetDenseIterator<T>& rhs) const noexcept {
-                return ! (*this == rhs);
+                return !(*this == rhs);
             }
 
             T operator*() const noexcept {
@@ -183,22 +191,22 @@ namespace osmium {
             // which would mean less (but larger) memory allocations. For
             // relations Ids it could be smaller, because they would all fit
             // into a smaller allocation.
-            constexpr static const std::size_t chunk_bits = 22;
-            constexpr static const std::size_t chunk_size = 1 << chunk_bits;
+            constexpr static const std::size_t chunk_bits = 22u;
+            constexpr static const std::size_t chunk_size = 1u << chunk_bits;
 
             std::vector<std::unique_ptr<unsigned char[]>> m_data;
             T m_size = 0;
 
             static std::size_t chunk_id(T id) noexcept {
-                return id >> (chunk_bits + 3);
+                return id >> (chunk_bits + 3u);
             }
 
             static std::size_t offset(T id) noexcept {
-                return (id >> 3) & ((1 << chunk_bits) - 1);
+                return (id >> 3u) & ((1u << chunk_bits) - 1u);
             }
 
             static unsigned char bitmask(T id) noexcept {
-                return 1 << (id & 0x7);
+                return 1u << (id & 0x7u);
             }
 
             T last() const noexcept {
@@ -422,7 +430,7 @@ namespace osmium {
         }; // class IdSetSmall
 
         /// @deprecated Use nwr_array helper class instead.
-        template <template<typename> class IdSetType>
+        template <template <typename> class IdSetType>
         class NWRIdSet {
 
             using id_set_type = IdSetType<osmium::unsigned_object_id_type>;
diff --git a/third_party/libosmium/include/osmium/index/index.hpp b/third_party/libosmium/include/osmium/index/index.hpp
index 325b42f9354..ca9e660d0ba 100644
--- a/third_party/libosmium/include/osmium/index/index.hpp
+++ b/third_party/libosmium/include/osmium/index/index.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map.hpp b/third_party/libosmium/include/osmium/index/map.hpp
index e0f9aecef51..a9fe9a390f1 100644
--- a/third_party/libosmium/include/osmium/index/map.hpp
+++ b/third_party/libosmium/include/osmium/index/map.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/string.hpp>
+
 #include <algorithm>
 #include <cstddef>
 #include <functional>
@@ -43,8 +45,6 @@ DEALINGS IN THE SOFTWARE.
 #include <type_traits>
 #include <vector>
 
-#include <osmium/util/string.hpp>
-
 namespace osmium {
 
     struct map_factory_error : public std::runtime_error {
@@ -98,13 +98,10 @@ namespace osmium {
                 static_assert(std::is_integral<TId>::value && std::is_unsigned<TId>::value,
                               "TId template parameter for class Map must be unsigned integral type");
 
-                Map(const Map&) = delete;
-                Map& operator=(const Map&) = delete;
-
             protected:
 
-                Map(Map&&) = default;
-                Map& operator=(Map&&) = default;
+                Map(Map&&) noexcept = default;
+                Map& operator=(Map&&) noexcept = default;
 
             public:
 
@@ -114,11 +111,14 @@ namespace osmium {
                 /// The "value" type, usually a Location or size_t.
                 using value_type = TValue;
 
-                Map() = default;
+                Map() noexcept = default;
+
+                Map(const Map&) = delete;
+                Map& operator=(const Map&) = delete;
 
                 virtual ~Map() noexcept = default;
 
-                virtual void reserve(const size_t) {
+                virtual void reserve(const size_t /*size*/) {
                     // default implementation is empty
                 }
 
@@ -210,14 +210,16 @@ namespace osmium {
 
             MapFactory() = default;
 
+            ~MapFactory() = default;
+
+        public:
+
             MapFactory(const MapFactory&) = delete;
             MapFactory& operator=(const MapFactory&) = delete;
 
             MapFactory(MapFactory&&) = delete;
             MapFactory& operator=(MapFactory&&) = delete;
 
-        public:
-
             static MapFactory<id_type, value_type>& instance() {
                 static MapFactory<id_type, value_type> factory;
                 return factory;
@@ -262,16 +264,16 @@ namespace osmium {
 
         namespace map {
 
-            template <typename TId, typename TValue, template<typename, typename> class TMap>
+            template <typename TId, typename TValue, template <typename, typename> class TMap>
             struct create_map {
-                TMap<TId, TValue>* operator()(const std::vector<std::string>&) {
+                TMap<TId, TValue>* operator()(const std::vector<std::string>& /*config_string*/) {
                     return new TMap<TId, TValue>();
                 }
             };
 
         } // namespace map
 
-        template <typename TId, typename TValue, template<typename, typename> class TMap>
+        template <typename TId, typename TValue, template <typename, typename> class TMap>
         inline bool register_map(const std::string& name) {
             return osmium::index::MapFactory<TId, TValue>::instance().register_map(name, [](const std::vector<std::string>& config) {
                 return map::create_map<TId, TValue, TMap>()(config);
@@ -283,10 +285,11 @@ namespace osmium {
 
 #define REGISTER_MAP(id, value, klass, name) \
 namespace osmium { namespace index { namespace detail { \
-    const bool OSMIUM_CONCATENATE_(registered_, name) = osmium::index::register_map<id, value, klass>(#name); \
-    inline bool OSMIUM_CONCATENATE_(get_registered_, name)() noexcept { \
-        return OSMIUM_CONCATENATE_(registered_, name); \
-    } \
+    namespace OSMIUM_CONCATENATE_(register_map_, __COUNTER__) { \
+    const bool registered = osmium::index::register_map<id, value, klass>(#name); \
+    inline bool get_registered() noexcept { \
+        return registered; \
+    } } \
 } } }
 
     } // namespace index
diff --git a/third_party/libosmium/include/osmium/index/map/all.hpp b/third_party/libosmium/include/osmium/index/map/all.hpp
index f196ffe17d7..948bc5ec814 100644
--- a/third_party/libosmium/include/osmium/index/map/all.hpp
+++ b/third_party/libosmium/include/osmium/index/map/all.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp b/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp
index c567612a1c8..da49c064212 100644
--- a/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <string>
-#include <vector>
-
+#include <osmium/index/detail/create_map_with_fd.hpp>
 #include <osmium/index/detail/mmap_vector_file.hpp>
 #include <osmium/index/detail/vector_map.hpp>
-#include <osmium/index/detail/create_map_with_fd.hpp>
+
+#include <string>
+#include <vector>
 
 #define OSMIUM_HAS_INDEX_MAP_DENSE_FILE_ARRAY
 
diff --git a/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp b/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp
index 839825873dd..84ca04969c9 100644
--- a/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,10 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <vector>
-
 #include <osmium/index/detail/vector_map.hpp>
 
+#include <vector>
+
 #define OSMIUM_HAS_INDEX_MAP_DENSE_MEM_ARRAY
 
 namespace osmium {
diff --git a/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp b/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp
index 8f51cc5d306..02e1883fb24 100644
--- a/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map/dummy.hpp b/third_party/libosmium/include/osmium/index/map/dummy.hpp
index de9a184677a..d6e396df486 100644
--- a/third_party/libosmium/include/osmium/index/map/dummy.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dummy.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-
 #include <osmium/index/index.hpp>
 #include <osmium/index/map.hpp>
 
+#include <cstddef>
+
 namespace osmium {
 
     namespace index {
@@ -56,9 +56,7 @@ namespace osmium {
 
                 Dummy() = default;
 
-                ~Dummy() noexcept final = default;
-
-                void set(const TId, const TValue) final {
+                void set(const TId /*id*/, const TValue /*value*/) final {
                     // intentionally left blank
                 }
 
diff --git a/third_party/libosmium/include/osmium/index/map/flex_mem.hpp b/third_party/libosmium/include/osmium/index/map/flex_mem.hpp
index db474e75db3..43bf9ce3bd6 100644
--- a/third_party/libosmium/include/osmium/index/map/flex_mem.hpp
+++ b/third_party/libosmium/include/osmium/index/map/flex_mem.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/index/index.hpp>
+#include <osmium/index/map.hpp>
+
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <utility>
 #include <vector>
 
-#include <osmium/index/map.hpp>
-#include <osmium/index/index.hpp>
-
 #define OSMIUM_HAS_INDEX_MAP_FLEX_MEM
 
 namespace osmium {
@@ -67,7 +67,7 @@ namespace osmium {
                 };
 
                 enum constant_block_size : uint64_t {
-                    block_size = 1ll << bits
+                    block_size = 1ull << bits
                 };
 
                 // Minimum number of entries in the sparse index before we
@@ -92,7 +92,7 @@ namespace osmium {
 
                     entry(uint64_t i, TValue v) :
                         id(i),
-                        value(v) {
+                        value(std::move(v)) {
                     }
 
                     bool operator<(const entry other) const noexcept {
@@ -179,8 +179,6 @@ namespace osmium {
                     m_dense(use_dense) {
                 }
 
-                ~FlexMem() noexcept final = default;
-
                 bool is_dense() const noexcept {
                     return m_dense;
                 }
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp b/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp
index 8898dd0a201..80bb37103e6 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <string>
-#include <vector>
-
+#include <osmium/index/detail/create_map_with_fd.hpp>
 #include <osmium/index/detail/mmap_vector_file.hpp>
 #include <osmium/index/detail/vector_map.hpp>
-#include <osmium/index/detail/create_map_with_fd.hpp>
+
+#include <string>
+#include <vector>
 
 #define OSMIUM_HAS_INDEX_MAP_SPARSE_FILE_ARRAY
 
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp
index 28255a5829f..6035a664399 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,10 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <vector>
-
 #include <osmium/index/detail/vector_map.hpp>
 
+#include <vector>
+
 #define OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_ARRAY
 
 namespace osmium {
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp
index 3287c333cc9..25b01b1bb06 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/index/index.hpp>
+#include <osmium/index/map.hpp>
+#include <osmium/io/detail/read_write.hpp>
+
 #include <algorithm> // IWYU pragma: keep (for std::copy)
 #include <cstddef>
 #include <iterator>
 #include <map>
 #include <vector>
 
-#include <osmium/index/map.hpp>
-#include <osmium/index/index.hpp>
-#include <osmium/io/detail/read_write.hpp>
-
 #define OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_MAP
 
 namespace osmium {
@@ -70,8 +70,6 @@ namespace osmium {
 
                 SparseMemMap() = default;
 
-                ~SparseMemMap() noexcept final = default;
-
                 void set(const TId id, const TValue value) final {
                     m_elements[id] = value;
                 }
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp
index b08384b6778..8d1a0422b01 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -35,16 +35,16 @@ DEALINGS IN THE SOFTWARE.
 
 #ifdef OSMIUM_WITH_SPARSEHASH
 
-#include <cstddef>
-#include <utility>
-#include <vector>
-
-#include <google/sparsetable>
-
 #include <osmium/index/index.hpp>
 #include <osmium/index/map.hpp>
 #include <osmium/io/detail/read_write.hpp>
 
+#include <google/sparsetable>
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
 #define OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_TABLE
 
 namespace osmium {
@@ -88,8 +88,6 @@ namespace osmium {
                     m_elements(grow_size) {
                 }
 
-                ~SparseMemTable() noexcept final = default;
-
                 void set(const TId id, const TValue value) final {
                     if (id >= m_elements.size()) {
                         m_elements.resize(id + m_grow_size);
@@ -121,7 +119,7 @@ namespace osmium {
 
                 size_t used_memory() const final {
                     // unused elements use 1 bit, used elements sizeof(TValue) bytes
-                    // http://google-sparsehash.googlecode.com/svn/trunk/doc/sparsetable.html
+                    // https://github.com/sparsehash/sparsehash/blob/master/doc/sparsetable.html
                     return (m_elements.size() / 8) + (m_elements.num_nonempty() * sizeof(TValue));
                 }
 
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp
index 03b49a5e704..47310e83c89 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/multimap.hpp b/third_party/libosmium/include/osmium/index/multimap.hpp
index 1b0964ed400..5d9b610fadb 100644
--- a/third_party/libosmium/include/osmium/index/multimap.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -54,13 +54,10 @@ namespace osmium {
 
                 using element_type = typename std::pair<TId, TValue>;
 
-                Multimap(const Multimap&) = delete;
-                Multimap& operator=(const Multimap&) = delete;
-
             protected:
 
-                Multimap(Multimap&&) = default;
-                Multimap& operator=(Multimap&&) = default;
+                Multimap(Multimap&&) noexcept = default;
+                Multimap& operator=(Multimap&&) noexcept = default;
 
             public:
 
@@ -72,6 +69,9 @@ namespace osmium {
 
                 Multimap() = default;
 
+                Multimap(const Multimap&) = delete;
+                Multimap& operator=(const Multimap&) = delete;
+
                 virtual ~Multimap() noexcept = default;
 
                 /// Set the field with id to value.
diff --git a/third_party/libosmium/include/osmium/index/multimap/all.hpp b/third_party/libosmium/include/osmium/index/multimap/all.hpp
index 1420b303b15..989f0ad904b 100644
--- a/third_party/libosmium/include/osmium/index/multimap/all.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/all.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp b/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp
index c49cad129a9..3c1d049b66a 100644
--- a/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-#include <utility>
-
 #include <osmium/index/index.hpp>
 #include <osmium/index/multimap.hpp>
 #include <osmium/index/multimap/sparse_mem_array.hpp>
 #include <osmium/index/multimap/sparse_mem_multimap.hpp>
 
+#include <cstddef>
+#include <utility>
+
 namespace osmium {
 
     namespace index {
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp
index a596e03130d..e5f5b9226a8 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp
index a152bf28afd..a6d7a5ac994 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,10 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <vector>
-
 #include <osmium/index/detail/vector_multimap.hpp>
 
+#include <vector>
+
 namespace osmium {
 
     namespace index {
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp
index 6aa26cffa5b..917a5a04d9e 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/index/multimap.hpp>
+#include <osmium/io/detail/read_write.hpp>
+
 #include <algorithm>
 #include <cstddef>
 #include <map>
 #include <utility>
 #include <vector>
 
-#include <osmium/index/multimap.hpp>
-#include <osmium/io/detail/read_write.hpp>
-
 namespace osmium {
 
     namespace index {
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp
index ef86b361ff5..87629f78605 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/node_locations_map.hpp b/third_party/libosmium/include/osmium/index/node_locations_map.hpp
index 0e78de1338d..70eb264d012 100644
--- a/third_party/libosmium/include/osmium/index/node_locations_map.hpp
+++ b/third_party/libosmium/include/osmium/index/node_locations_map.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,6 +34,8 @@ DEALINGS IN THE SOFTWARE.
 */
 
 #include <osmium/index/map.hpp> // IWYU pragma: keep
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
 
 #define OSMIUM_WANT_NODE_LOCATION_MAPS
 
diff --git a/third_party/libosmium/include/osmium/index/nwr_array.hpp b/third_party/libosmium/include/osmium/index/nwr_array.hpp
index 2c52c7e8f53..69132bd49cd 100644
--- a/third_party/libosmium/include/osmium/index/nwr_array.hpp
+++ b/third_party/libosmium/include/osmium/index/nwr_array.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/relations_map.hpp b/third_party/libosmium/include/osmium/index/relations_map.hpp
index bc2671959df..f514940d11c 100644
--- a/third_party/libosmium/include/osmium/index/relations_map.hpp
+++ b/third_party/libosmium/include/osmium/index/relations_map.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,10 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/types.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -42,10 +46,6 @@ DEALINGS IN THE SOFTWARE.
 #include <utility>
 #include <vector>
 
-#include <osmium/osm/item_type.hpp>
-#include <osmium/osm/relation.hpp>
-#include <osmium/osm/types.hpp>
-
 namespace osmium {
 
     namespace index {
@@ -187,8 +187,10 @@ namespace osmium {
             RelationsMapIndex(const RelationsMapIndex&) = delete;
             RelationsMapIndex& operator=(const RelationsMapIndex&) = delete;
 
-            RelationsMapIndex(RelationsMapIndex&&) = default;
-            RelationsMapIndex& operator=(RelationsMapIndex&&) = default;
+            RelationsMapIndex(RelationsMapIndex&& /*other*/) noexcept(std::is_nothrow_move_constructible<map_type>::value);
+            RelationsMapIndex& operator=(RelationsMapIndex&& /*other*/) noexcept(std::is_nothrow_move_assignable<map_type>::value);
+
+            ~RelationsMapIndex() noexcept = default;
 
             /**
              * Find the given relation id in the index and call the given
@@ -256,6 +258,11 @@ namespace osmium {
 
         }; // class RelationsMapIndex
 
+        // defined outside the class on purpose
+        // see https://akrzemi1.wordpress.com/2015/09/11/declaring-the-move-constructor/
+        inline RelationsMapIndex::RelationsMapIndex(RelationsMapIndex&&) noexcept(std::is_nothrow_move_constructible<map_type>::value) = default;
+        inline RelationsMapIndex& RelationsMapIndex::operator=(RelationsMapIndex&&) noexcept(std::is_nothrow_move_assignable<map_type>::value) = default;
+
         class RelationsMapIndexes {
 
             friend class RelationsMapStash;
@@ -321,8 +328,10 @@ namespace osmium {
             RelationsMapStash(const RelationsMapStash&) = delete;
             RelationsMapStash& operator=(const RelationsMapStash&) = delete;
 
-            RelationsMapStash(RelationsMapStash&&) = default;
-            RelationsMapStash& operator=(RelationsMapStash&&) = default;
+            RelationsMapStash(RelationsMapStash&& /*other*/) noexcept(std::is_nothrow_move_constructible<map_type>::value);
+            RelationsMapStash& operator=(RelationsMapStash&& /*other*/) noexcept(std::is_nothrow_move_assignable<map_type>::value);
+
+            ~RelationsMapStash() noexcept = default;
 
             /**
              * Add mapping from member to parent relation in the stash.
@@ -431,6 +440,11 @@ namespace osmium {
 
         }; // class RelationsMapStash
 
+        // defined outside the class on purpose
+        // see https://akrzemi1.wordpress.com/2015/09/11/declaring-the-move-constructor/
+        inline RelationsMapStash::RelationsMapStash(RelationsMapStash&&) noexcept(std::is_nothrow_move_constructible<map_type>::value) = default;
+        inline RelationsMapStash& RelationsMapStash::operator=(RelationsMapStash&&) noexcept(std::is_nothrow_move_assignable<map_type>::value) = default;
+
     } // namespace index
 
 } // namespace osmium
diff --git a/third_party/libosmium/include/osmium/io/any_compression.hpp b/third_party/libosmium/include/osmium/io/any_compression.hpp
index 9ccc3f7c305..ab3384226e1 100644
--- a/third_party/libosmium/include/osmium/io/any_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/any_compression.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/any_input.hpp b/third_party/libosmium/include/osmium/io/any_input.hpp
index 043c99d0d1e..d2708592f84 100644
--- a/third_party/libosmium/include/osmium/io/any_input.hpp
+++ b/third_party/libosmium/include/osmium/io/any_input.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/any_output.hpp b/third_party/libosmium/include/osmium/io/any_output.hpp
index 32cc344bd82..52f989e6222 100644
--- a/third_party/libosmium/include/osmium/io/any_output.hpp
+++ b/third_party/libosmium/include/osmium/io/any_output.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/bzip2_compression.hpp b/third_party/libosmium/include/osmium/io/bzip2_compression.hpp
index 094062c80c5..b3d2161149e 100644
--- a/third_party/libosmium/include/osmium/io/bzip2_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/bzip2_compression.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,25 +42,26 @@ DEALINGS IN THE SOFTWARE.
  * @attention If you include this file, you'll need to link with `libbz2`.
  */
 
+#include <osmium/io/compression.hpp>
+#include <osmium/io/detail/read_write.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/io/writer_options.hpp>
+#include <osmium/util/compatibility.hpp>
+
+#include <bzlib.h>
+
+#include <cassert>
 #include <cerrno>
 #include <cstdio>
+#include <limits>
 #include <string>
 #include <system_error>
 
-#include <bzlib.h>
-
 #ifndef _MSC_VER
 # include <unistd.h>
 #endif
 
-#include <osmium/io/compression.hpp>
-#include <osmium/io/detail/read_write.hpp>
-#include <osmium/io/error.hpp>
-#include <osmium/io/file_compression.hpp>
-#include <osmium/io/writer_options.hpp>
-#include <osmium/util/cast.hpp>
-#include <osmium/util/compatibility.hpp>
-
 namespace osmium {
 
     /**
@@ -117,6 +118,12 @@ namespace osmium {
                 }
             }
 
+            Bzip2Compressor(const Bzip2Compressor&) = delete;
+            Bzip2Compressor& operator=(const Bzip2Compressor&) = delete;
+
+            Bzip2Compressor(Bzip2Compressor&&) = delete;
+            Bzip2Compressor& operator=(Bzip2Compressor&&) = delete;
+
             ~Bzip2Compressor() noexcept final {
                 try {
                     close();
@@ -127,7 +134,8 @@ namespace osmium {
 
             void write(const std::string& data) final {
                 int error;
-                ::BZ2_bzWrite(&error, m_bzfile, const_cast<char*>(data.data()), static_cast_with_assert<int>(data.size()));
+                assert(data.size() < std::numeric_limits<int>::max());
+                ::BZ2_bzWrite(&error, m_bzfile, const_cast<char*>(data.data()), static_cast<int>(data.size()));
                 if (error != BZ_OK && error != BZ_STREAM_END) {
                     detail::throw_bzip2_error(m_bzfile, "write failed", error);
                 }
@@ -157,22 +165,26 @@ namespace osmium {
         class Bzip2Decompressor : public Decompressor {
 
             FILE* m_file;
-            int m_bzerror;
+            int m_bzerror = BZ_OK;
             BZFILE* m_bzfile;
-            bool m_stream_end {false};
+            bool m_stream_end = false;
 
         public:
 
             explicit Bzip2Decompressor(int fd) :
-                Decompressor(),
                 m_file(fdopen(::dup(fd), "rb")),
-                m_bzerror(BZ_OK),
                 m_bzfile(::BZ2_bzReadOpen(&m_bzerror, m_file, 0, 0, nullptr, 0)) {
                 if (!m_bzfile) {
                     detail::throw_bzip2_error(m_bzfile, "read open failed", m_bzerror);
                 }
             }
 
+            Bzip2Decompressor(const Bzip2Decompressor&) = delete;
+            Bzip2Decompressor& operator=(const Bzip2Decompressor&) = delete;
+
+            Bzip2Decompressor(Bzip2Decompressor&&) = delete;
+            Bzip2Decompressor& operator=(Bzip2Decompressor&&) = delete;
+
             ~Bzip2Decompressor() noexcept final {
                 try {
                     close();
@@ -187,7 +199,8 @@ namespace osmium {
                 if (!m_stream_end) {
                     buffer.resize(osmium::io::Decompressor::input_buffer_size);
                     int error;
-                    const int nread = ::BZ2_bzRead(&error, m_bzfile, const_cast<char*>(buffer.data()), static_cast_with_assert<int>(buffer.size()));
+                    assert(buffer.size() < std::numeric_limits<int>::max());
+                    const int nread = ::BZ2_bzRead(&error, m_bzfile, const_cast<char*>(buffer.data()), static_cast<int>(buffer.size()));
                     if (error != BZ_OK && error != BZ_STREAM_END) {
                         detail::throw_bzip2_error(m_bzfile, "read failed", error);
                     }
@@ -204,7 +217,8 @@ namespace osmium {
                             if (error != BZ_OK) {
                                 detail::throw_bzip2_error(m_bzfile, "read close failed", error);
                             }
-                            m_bzfile = ::BZ2_bzReadOpen(&error, m_file, 0, 0, const_cast<void*>(static_cast<const void*>(unused_data.data())), static_cast_with_assert<int>(unused_data.size()));
+                            assert(unused_data.size() < std::numeric_limits<int>::max());
+                            m_bzfile = ::BZ2_bzReadOpen(&error, m_file, 0, 0, const_cast<void*>(static_cast<const void*>(unused_data.data())), static_cast<int>(unused_data.size()));
                             if (error != BZ_OK) {
                                 detail::throw_bzip2_error(m_bzfile, "read open failed", error);
                             }
@@ -251,7 +265,8 @@ namespace osmium {
                 m_buffer_size(size),
                 m_bzstream() {
                 m_bzstream.next_in = const_cast<char*>(buffer);
-                m_bzstream.avail_in = static_cast_with_assert<unsigned int>(size);
+                assert(size < std::numeric_limits<unsigned int>::max());
+                m_bzstream.avail_in = static_cast<unsigned int>(size);
                 const int result = BZ2_bzDecompressInit(&m_bzstream, 0, 0);
                 if (result != BZ_OK) {
                     std::string message{"bzip2 error: decompression init failed: "};
@@ -259,6 +274,12 @@ namespace osmium {
                 }
             }
 
+            Bzip2BufferDecompressor(const Bzip2BufferDecompressor&) = delete;
+            Bzip2BufferDecompressor& operator=(const Bzip2BufferDecompressor&) = delete;
+
+            Bzip2BufferDecompressor(Bzip2BufferDecompressor&&) = delete;
+            Bzip2BufferDecompressor& operator=(Bzip2BufferDecompressor&&) = delete;
+
             ~Bzip2BufferDecompressor() noexcept final {
                 try {
                     close();
@@ -287,7 +308,7 @@ namespace osmium {
                         throw bzip2_error{message, result};
                     }
 
-                    output.resize(static_cast<unsigned long>(m_bzstream.next_out - output.data()));
+                    output.resize(static_cast<std::size_t>(m_bzstream.next_out - output.data()));
                 }
 
                 return output;
diff --git a/third_party/libosmium/include/osmium/io/compression.hpp b/third_party/libosmium/include/osmium/io/compression.hpp
index c3b8706a40e..b26d279f390 100644
--- a/third_party/libosmium/include/osmium/io/compression.hpp
+++ b/third_party/libosmium/include/osmium/io/compression.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/io/detail/read_write.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/io/writer_options.hpp>
+#include <osmium/util/file.hpp>
+
 #include <atomic>
 #include <cerrno>
 #include <cstddef>
@@ -50,12 +56,6 @@ DEALINGS IN THE SOFTWARE.
 # include <io.h>
 #endif
 
-#include <osmium/io/detail/read_write.hpp>
-#include <osmium/io/error.hpp>
-#include <osmium/io/file_compression.hpp>
-#include <osmium/io/writer_options.hpp>
-#include <osmium/util/file.hpp>
-
 namespace osmium {
 
     namespace io {
@@ -76,6 +76,12 @@ namespace osmium {
                 m_fsync(sync) {
             }
 
+            Compressor(const Compressor&) = default;
+            Compressor& operator=(const Compressor&) = default;
+
+            Compressor(Compressor&&) noexcept = default;
+            Compressor& operator=(Compressor&&) noexcept = default;
+
             virtual ~Compressor() noexcept = default;
 
             virtual void write(const std::string& data) = 0;
@@ -152,12 +158,6 @@ namespace osmium {
 
             CompressionFactory() = default;
 
-            CompressionFactory(const CompressionFactory&) = delete;
-            CompressionFactory& operator=(const CompressionFactory&) = delete;
-
-            CompressionFactory(CompressionFactory&&) = delete;
-            CompressionFactory& operator=(CompressionFactory&&) = delete;
-
             const callbacks_type& find_callbacks(osmium::io::file_compression compression) const {
                 const auto it = m_callbacks.find(compression);
 
@@ -173,6 +173,14 @@ namespace osmium {
 
         public:
 
+            CompressionFactory(const CompressionFactory&) = delete;
+            CompressionFactory& operator=(const CompressionFactory&) = delete;
+
+            CompressionFactory(CompressionFactory&&) = delete;
+            CompressionFactory& operator=(CompressionFactory&&) = delete;
+
+            ~CompressionFactory() noexcept = default;
+
             static CompressionFactory& instance() {
                 static CompressionFactory factory;
                 return factory;
@@ -201,7 +209,7 @@ namespace osmium {
             std::unique_ptr<osmium::io::Decompressor> create_decompressor(osmium::io::file_compression compression, int fd) const {
                 const auto callbacks = find_callbacks(compression);
                 auto p = std::unique_ptr<osmium::io::Decompressor>(std::get<1>(callbacks)(fd));
-                p->set_file_size(osmium::util::file_size(fd));
+                p->set_file_size(osmium::file_size(fd));
                 return p;
             }
 
@@ -223,6 +231,12 @@ namespace osmium {
                 m_fd(fd) {
             }
 
+            NoCompressor(const NoCompressor&) = delete;
+            NoCompressor& operator=(const NoCompressor&) = delete;
+
+            NoCompressor(NoCompressor&&) = delete;
+            NoCompressor& operator=(NoCompressor&&) = delete;
+
             ~NoCompressor() noexcept final {
                 try {
                     close();
@@ -250,27 +264,28 @@ namespace osmium {
 
         class NoDecompressor : public Decompressor {
 
-            int m_fd;
-            const char *m_buffer;
-            std::size_t m_buffer_size;
+            int m_fd = -1;
+            const char* m_buffer = nullptr;
+            std::size_t m_buffer_size = 0;
             std::size_t m_offset = 0;
 
         public:
 
             explicit NoDecompressor(int fd) :
-                Decompressor(),
-                m_fd(fd),
-                m_buffer(nullptr),
-                m_buffer_size(0) {
+                m_fd(fd) {
             }
 
             NoDecompressor(const char* buffer, std::size_t size) :
-                Decompressor(),
-                m_fd(-1),
                 m_buffer(buffer),
                 m_buffer_size(size) {
             }
 
+            NoDecompressor(const NoDecompressor&) = delete;
+            NoDecompressor& operator=(const NoDecompressor&) = delete;
+
+            NoDecompressor(NoDecompressor&&) = delete;
+            NoDecompressor& operator=(NoDecompressor&&) = delete;
+
             ~NoDecompressor() noexcept final {
                 try {
                     close();
@@ -290,10 +305,7 @@ namespace osmium {
                     }
                 } else {
                     buffer.resize(osmium::io::Decompressor::input_buffer_size);
-                    const auto nread = ::read(m_fd, const_cast<char*>(buffer.data()), osmium::io::Decompressor::input_buffer_size);
-                    if (nread < 0) {
-                        throw std::system_error{errno, std::system_category(), "Read failed"};
-                    }
+                    const auto nread = detail::reliable_read(m_fd, const_cast<char*>(buffer.data()), osmium::io::Decompressor::input_buffer_size);
                     buffer.resize(std::string::size_type(nread));
                 }
 
diff --git a/third_party/libosmium/include/osmium/io/debug_output.hpp b/third_party/libosmium/include/osmium/io/debug_output.hpp
index 80c3954c3e5..eac514f10ea 100644
--- a/third_party/libosmium/include/osmium/io/debug_output.hpp
+++ b/third_party/libosmium/include/osmium/io/debug_output.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,7 +33,7 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/io/writer.hpp> // IWYU pragma: export
 #include <osmium/io/detail/debug_output_format.hpp> // IWYU pragma: export
+#include <osmium/io/writer.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_DEBUG_OUTPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp
index f7ce7c838c6..30909418a5d 100644
--- a/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cinttypes>
-#include <cmath>
-#include <cstring>
-#include <iterator>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include <boost/crc.hpp>
-
 #include <osmium/io/detail/output_format.hpp>
 #include <osmium/io/detail/queue_util.hpp>
 #include <osmium/io/detail/string_util.hpp>
@@ -56,6 +46,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/crc.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
+#include <osmium/osm/metadata_options.hpp>
 #include <osmium/osm/node.hpp>
 #include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/object.hpp>
@@ -68,6 +59,16 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/util/minmax.hpp>
 #include <osmium/visitor.hpp>
 
+#include <boost/crc.hpp>
+
+#include <cinttypes>
+#include <cmath>
+#include <cstring>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace io {
@@ -92,18 +93,19 @@ namespace osmium {
 
             struct debug_output_options {
 
-                /// Should metadata of objects be added?
-                bool add_metadata;
+                /// Which metadata of objects should be added?
+                osmium::metadata_options add_metadata;
 
                 /// Output with ANSI colors?
-                bool use_color;
+                bool use_color = false;
 
                 /// Add CRC32 checksum to each object?
-                bool add_crc32;
+                bool add_crc32 = false;
 
                 /// Write in form of a diff file?
-                bool format_as_diff;
-            };
+                bool format_as_diff = false;
+
+            }; // struct debug_output_options
 
             /**
              * Writes out one buffer with OSM data in Debug format.
@@ -144,7 +146,8 @@ namespace osmium {
                             *m_out += '-';
                             *m_out += color_reset;
                             return;
-                        } else if (m_diff_char == '+') {
+                        }
+                        if (m_diff_char == '+') {
                             *m_out += color_backg_green;
                             *m_out += color_white;
                             *m_out += color_bold;
@@ -218,26 +221,36 @@ namespace osmium {
 
                 void write_meta(const osmium::OSMObject& object) {
                     output_int(object.id());
-                    *m_out += '\n';
-                    if (m_options.add_metadata) {
+                    if (object.visible()) {
+                        *m_out += " visible\n";
+                    } else {
+                        write_error(" deleted\n");
+                    }
+                    if (m_options.add_metadata.version()) {
                         write_fieldname("version");
                         *m_out += "  ";
                         output_int(object.version());
-                        if (object.visible()) {
-                            *m_out += " visible\n";
-                        } else {
-                            write_error(" deleted\n");
-                        }
+                        *m_out += '\n';
+                    }
+                    if (m_options.add_metadata.changeset()) {
                         write_fieldname("changeset");
                         output_int(object.changeset());
                         *m_out += '\n';
+                    }
+                    if (m_options.add_metadata.timestamp()) {
                         write_fieldname("timestamp");
                         write_timestamp(object.timestamp());
+                    }
+                    if (m_options.add_metadata.user() || m_options.add_metadata.uid()) {
                         write_fieldname("user");
                         *m_out += "     ";
-                        output_int(object.uid());
-                        *m_out += ' ';
-                        write_string(object.user());
+                        if (m_options.add_metadata.uid()) {
+                            output_int(object.uid());
+                            *m_out += ' ';
+                        }
+                        if (m_options.add_metadata.user()) {
+                            write_string(object.user());
+                        }
                         *m_out += '\n';
                     }
                 }
@@ -261,8 +274,9 @@ namespace osmium {
                         *m_out += "    ";
                         write_string(tag.key());
                         auto spacing = max() - std::strlen(tag.key());
-                        while (spacing--) {
+                        while (spacing > 0) {
                             *m_out += " ";
+                            --spacing;
                         }
                         *m_out += " = ";
                         write_string(tag.value());
@@ -322,14 +336,6 @@ namespace osmium {
                     m_utf8_suffix(options.use_color ? color_blue : "") {
                 }
 
-                DebugOutputBlock(const DebugOutputBlock&) = default;
-                DebugOutputBlock& operator=(const DebugOutputBlock&) = default;
-
-                DebugOutputBlock(DebugOutputBlock&&) = default;
-                DebugOutputBlock& operator=(DebugOutputBlock&&) = default;
-
-                ~DebugOutputBlock() noexcept = default;
-
                 std::string operator()() {
                     osmium::apply(m_input_buffer->cbegin(), m_input_buffer->cend(), *this);
 
@@ -522,19 +528,13 @@ namespace osmium {
             public:
 
                 DebugOutputFormat(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) :
-                    OutputFormat(pool, output_queue),
-                    m_options() {
-                    m_options.add_metadata   = file.is_not_false("add_metadata");
+                    OutputFormat(pool, output_queue) {
+                    m_options.add_metadata   = osmium::metadata_options{file.get("add_metadata")};
                     m_options.use_color      = file.is_true("color");
                     m_options.add_crc32      = file.is_true("add_crc32");
                     m_options.format_as_diff = file.is_true("diff");
                 }
 
-                DebugOutputFormat(const DebugOutputFormat&) = delete;
-                DebugOutputFormat& operator=(const DebugOutputFormat&) = delete;
-
-                ~DebugOutputFormat() noexcept final = default;
-
                 void write_header(const osmium::io::Header& header) final {
                     if (m_options.format_as_diff) {
                         return;
diff --git a/third_party/libosmium/include/osmium/io/detail/input_format.hpp b/third_party/libosmium/include/osmium/io/detail/input_format.hpp
index 7ba6677b1f4..d8f0fef2e92 100644
--- a/third_party/libosmium/include/osmium/io/detail/input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/input_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <exception>
-#include <functional>
-#include <future>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-
 #include <osmium/io/detail/queue_util.hpp>
 #include <osmium/io/error.hpp>
 #include <osmium/io/file.hpp>
@@ -50,6 +42,14 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/entity_bits.hpp>
 #include <osmium/thread/pool.hpp>
 
+#include <array>
+#include <exception>
+#include <functional>
+#include <future>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace io {
@@ -177,37 +177,41 @@ namespace osmium {
 
             private:
 
-                using map_type = std::map<osmium::io::file_format, create_parser_type>;
+                std::array<create_parser_type, static_cast<std::size_t>(file_format::last) + 1> m_callbacks;
 
-                map_type m_callbacks;
+                ParserFactory() noexcept = default;
+
+                create_parser_type& callbacks(const osmium::io::file_format format) noexcept {
+                    return m_callbacks[static_cast<std::size_t>(format)];
+                }
 
-                ParserFactory() :
-                    m_callbacks() {
+                const create_parser_type& callbacks(const osmium::io::file_format format) const noexcept {
+                    return m_callbacks[static_cast<std::size_t>(format)];
                 }
 
             public:
 
-                static ParserFactory& instance() {
+                static ParserFactory& instance() noexcept {
                     static ParserFactory factory;
                     return factory;
                 }
 
-                bool register_parser(osmium::io::file_format format, create_parser_type&& create_function) {
-                    const auto result = m_callbacks.emplace(format, std::forward<create_parser_type>(create_function));
-                    return result.second;
+                bool register_parser(const osmium::io::file_format format, create_parser_type&& create_function) {
+                    callbacks(format) = std::forward<create_parser_type>(create_function);
+                    return true;
                 }
 
                 create_parser_type get_creator_function(const osmium::io::File& file) const {
-                    const auto it = m_callbacks.find(file.format());
-                    if (it == m_callbacks.end()) {
-                        throw unsupported_file_format_error{
-                                std::string{"Can not open file '"} +
-                                file.filename() +
-                                "' with type '" +
-                                as_string(file.format()) +
-                                "'. No support for reading this format in this program."};
+                    const auto func = callbacks(file.format());
+                    if (func) {
+                        return func;
                     }
-                    return it->second;
+                    throw unsupported_file_format_error{
+                            std::string{"Can not open file '"} +
+                            file.filename() +
+                            "' with type '" +
+                            as_string(file.format()) +
+                            "'. No support for reading this format in this program."};
                 }
 
             }; // class ParserFactory
diff --git a/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp
index e0b3fa82e64..41976dbec4f 100644
--- a/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,18 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <future>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include <protozero/exception.hpp>
-#include <protozero/varint.hpp>
-
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/io/detail/input_format.hpp>
 #include <osmium/io/detail/queue_util.hpp>
@@ -63,9 +51,21 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 #include <osmium/thread/util.hpp>
-#include <osmium/util/cast.hpp>
 #include <osmium/util/delta.hpp>
 
+#include <protozero/exception.hpp>
+#include <protozero/varint.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <future>
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace builder {
@@ -90,7 +90,7 @@ namespace osmium {
         namespace detail {
 
             // Implementation of the o5m/o5c file formats according to the
-            // description at http://wiki.openstreetmap.org/wiki/O5m .
+            // description at https://wiki.openstreetmap.org/wiki/O5m .
 
             class ReferenceTable {
 
@@ -137,7 +137,7 @@ namespace osmium {
                     if (m_table.empty() || index == 0 || index > number_of_entries) {
                         throw o5m_error{"reference to non-existing string in table"};
                     }
-                    auto entry = (current_entry + number_of_entries - index) % number_of_entries;
+                    const auto entry = (current_entry + number_of_entries - index) % number_of_entries;
                     return &m_table[entry * entry_size];
                 }
 
@@ -145,13 +145,13 @@ namespace osmium {
 
             class O5mParser : public Parser {
 
-                static constexpr int buffer_size = 2 * 1000 * 1000;
+                static constexpr std::size_t buffer_size = 2 * 1000 * 1000;
 
-                osmium::io::Header m_header;
+                osmium::io::Header m_header{};
 
                 osmium::memory::Buffer m_buffer;
 
-                std::string m_input;
+                std::string m_input{};
 
                 const char* m_data;
                 const char* m_end;
@@ -163,7 +163,7 @@ namespace osmium {
                 }
 
                 bool ensure_bytes_available(std::size_t need_bytes) {
-                    if ((m_end - m_data) >= long(need_bytes)) {
+                    if ((m_end - m_data) >= static_cast<int64_t>(need_bytes)) {
                         return true;
                     }
 
@@ -190,7 +190,7 @@ namespace osmium {
                 void check_header_magic() {
                     static const unsigned char header_magic[] = { 0xff, 0xe0, 0x04, 'o', '5' };
 
-                    if (std::strncmp(reinterpret_cast<const char*>(header_magic), m_data, sizeof(header_magic))) {
+                    if (std::strncmp(reinterpret_cast<const char*>(header_magic), m_data, sizeof(header_magic)) != 0) {
                         throw o5m_error{"wrong header magic"};
                     }
 
@@ -231,15 +231,15 @@ namespace osmium {
                     set_header_value(m_header);
                 }
 
-                osmium::util::DeltaDecode<osmium::object_id_type> m_delta_id;
+                osmium::DeltaDecode<osmium::object_id_type> m_delta_id;
 
-                osmium::util::DeltaDecode<int64_t> m_delta_timestamp;
-                osmium::util::DeltaDecode<osmium::changeset_id_type> m_delta_changeset;
-                osmium::util::DeltaDecode<int64_t> m_delta_lon;
-                osmium::util::DeltaDecode<int64_t> m_delta_lat;
+                osmium::DeltaDecode<int64_t> m_delta_timestamp;
+                osmium::DeltaDecode<osmium::changeset_id_type> m_delta_changeset;
+                osmium::DeltaDecode<int64_t> m_delta_lon;
+                osmium::DeltaDecode<int64_t> m_delta_lat;
 
-                osmium::util::DeltaDecode<osmium::object_id_type> m_delta_way_node_id;
-                osmium::util::DeltaDecode<osmium::object_id_type> m_delta_member_ids[3];
+                osmium::DeltaDecode<osmium::object_id_type> m_delta_way_node_id;
+                osmium::DeltaDecode<osmium::object_id_type> m_delta_member_ids[3];
 
                 void reset() {
                     m_reference_table.clear();
@@ -263,18 +263,21 @@ namespace osmium {
                             throw o5m_error{"string format error"};
                         }
                         return *dataptr;
-                    } else { // get from reference table
-                        auto index = protozero::decode_varint(dataptr, end);
-                        return m_reference_table.get(index);
                     }
+                    // get from reference table
+                    const auto index = protozero::decode_varint(dataptr, end);
+                    return m_reference_table.get(index);
                 }
 
                 std::pair<osmium::user_id_type, const char*> decode_user(const char** dataptr, const char* const end) {
-                    bool update_pointer = (**dataptr == 0x00);
+                    const bool update_pointer = (**dataptr == 0x00);
                     const char* data = decode_string(dataptr, end);
                     const char* start = data;
 
-                    auto uid = protozero::decode_varint(&data, end);
+                    const auto uid = protozero::decode_varint(&data, end);
+                    if (uid > std::numeric_limits<user_id_type>::max()) {
+                        throw o5m_error{"uid out of range"};
+                    }
 
                     if (data == end) {
                         throw o5m_error{"missing user name"};
@@ -285,7 +288,7 @@ namespace osmium {
                     if (uid == 0 && update_pointer) {
                         m_reference_table.add("\0\0", 2);
                         *dataptr = data;
-                        return std::make_pair(0, "");
+                        return {0, ""};
                     }
 
                     while (*data++) {
@@ -299,14 +302,14 @@ namespace osmium {
                         *dataptr = data;
                     }
 
-                    return std::make_pair(static_cast_with_assert<osmium::user_id_type>(uid), user);
+                    return {static_cast<osmium::user_id_type>(uid), user};
                 }
 
                 void decode_tags(osmium::builder::Builder& parent, const char** dataptr, const char* const end) {
                     osmium::builder::TagListBuilder builder{parent};
 
                     while (*dataptr != end) {
-                        bool update_pointer = (**dataptr == 0x00);
+                        const bool update_pointer = (**dataptr == 0x00);
                         const char* data = decode_string(dataptr, end);
                         const char* start = data;
 
@@ -316,6 +319,10 @@ namespace osmium {
                             }
                         }
 
+                        if (data == end) {
+                            throw o5m_error{"no null byte in tag value"};
+                        }
+
                         const char* value = data;
                         while (*data++) {
                             if (data == end) {
@@ -338,8 +345,13 @@ namespace osmium {
                     if (**dataptr == 0x00) { // no info section
                         ++*dataptr;
                     } else { // has info section
-                        object.set_version(static_cast_with_assert<object_version_type>(protozero::decode_varint(dataptr, end)));
-                        auto timestamp = m_delta_timestamp.update(zvarint(dataptr, end));
+                        const auto version = protozero::decode_varint(dataptr, end);
+                        if (version > std::numeric_limits<object_version_type>::max()) {
+                            throw o5m_error{"object version too large"};
+                        }
+                        object.set_version(static_cast<object_version_type>(version));
+
+                        const auto timestamp = m_delta_timestamp.update(zvarint(dataptr, end));
                         if (timestamp != 0) { // has timestamp
                             object.set_timestamp(timestamp);
                             object.set_changeset(m_delta_changeset.update(zvarint(dataptr, end)));
@@ -368,8 +380,8 @@ namespace osmium {
                         builder.set_visible(false);
                         builder.set_location(osmium::Location{});
                     } else {
-                        auto lon = m_delta_lon.update(zvarint(&data, end));
-                        auto lat = m_delta_lat.update(zvarint(&data, end));
+                        const auto lon = m_delta_lon.update(zvarint(&data, end));
+                        const auto lat = m_delta_lat.update(zvarint(&data, end));
                         builder.set_location(osmium::Location{lon, lat});
 
                         if (data != end) {
@@ -389,7 +401,7 @@ namespace osmium {
                         // no reference section, object is deleted
                         builder.set_visible(false);
                     } else {
-                        auto reference_section_length = protozero::decode_varint(&data, end);
+                        const auto reference_section_length = protozero::decode_varint(&data, end);
                         if (reference_section_length > 0) {
                             const char* const end_refs = data + reference_section_length;
                             if (end_refs > end) {
@@ -417,7 +429,7 @@ namespace osmium {
                 }
 
                 std::pair<osmium::item_type, const char*> decode_role(const char** dataptr, const char* const end) {
-                    bool update_pointer = (**dataptr == 0x00);
+                    const bool update_pointer = (**dataptr == 0x00);
                     const char* data = decode_string(dataptr, end);
                     const char* start = data;
 
@@ -438,7 +450,7 @@ namespace osmium {
                         *dataptr = data;
                     }
 
-                    return std::make_pair(member_type, role);
+                    return {member_type, role};
                 }
 
                 void decode_relation(const char* data, const char* const end) {
@@ -452,7 +464,7 @@ namespace osmium {
                         // no reference section, object is deleted
                         builder.set_visible(false);
                     } else {
-                        auto reference_section_length = protozero::decode_varint(&data, end);
+                        const auto reference_section_length = protozero::decode_varint(&data, end);
                         if (reference_section_length > 0) {
                             const char* const end_refs = data + reference_section_length;
                             if (end_refs > end) {
@@ -480,23 +492,23 @@ namespace osmium {
                 }
 
                 void decode_bbox(const char* data, const char* const end) {
-                    auto sw_lon = zvarint(&data, end);
-                    auto sw_lat = zvarint(&data, end);
-                    auto ne_lon = zvarint(&data, end);
-                    auto ne_lat = zvarint(&data, end);
+                    const auto sw_lon = zvarint(&data, end);
+                    const auto sw_lat = zvarint(&data, end);
+                    const auto ne_lon = zvarint(&data, end);
+                    const auto ne_lat = zvarint(&data, end);
 
                     m_header.add_box(osmium::Box{osmium::Location{sw_lon, sw_lat},
                                                  osmium::Location{ne_lon, ne_lat}});
                 }
 
                 void decode_timestamp(const char* data, const char* const end) {
-                    auto timestamp = osmium::Timestamp(zvarint(&data, end)).to_iso();
+                    const auto timestamp = osmium::Timestamp(zvarint(&data, end)).to_iso();
                     m_header.set("o5m_timestamp", timestamp);
                     m_header.set("timestamp", timestamp);
                 }
 
                 void flush() {
-                    osmium::memory::Buffer buffer(buffer_size);
+                    osmium::memory::Buffer buffer{buffer_size};
                     using std::swap;
                     swap(m_buffer, buffer);
                     send_to_output_queue(std::move(buffer));
@@ -516,7 +528,7 @@ namespace osmium {
 
                 void decode_data() {
                     while (ensure_bytes_available(1)) {
-                        dataset_type ds_type = dataset_type(*m_data++);
+                        const auto ds_type = static_cast<dataset_type>(*m_data++);
                         if (ds_type > dataset_type::jump) {
                             if (ds_type == dataset_type::reset) {
                                 reset();
@@ -591,13 +603,17 @@ namespace osmium {
 
                 explicit O5mParser(parser_arguments& args) :
                     Parser(args),
-                    m_header(),
                     m_buffer(buffer_size),
-                    m_input(),
                     m_data(m_input.data()),
                     m_end(m_data) {
                 }
 
+                O5mParser(const O5mParser&) = delete;
+                O5mParser& operator=(const O5mParser&) = delete;
+
+                O5mParser(O5mParser&&) = delete;
+                O5mParser& operator=(O5mParser&&) = delete;
+
                 ~O5mParser() noexcept final = default;
 
                 void run() final {
diff --git a/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp
index f5fcd00caf7..ba5fb8b5744 100644
--- a/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <utility>
-
 #include <osmium/io/detail/input_format.hpp>
 #include <osmium/io/detail/opl_parser_functions.hpp>
 #include <osmium/io/file_format.hpp>
@@ -45,6 +40,11 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/memory/buffer.hpp>
 #include <osmium/thread/util.hpp>
 
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace io {
@@ -120,6 +120,12 @@ namespace osmium {
                     set_header_value(osmium::io::Header{});
                 }
 
+                OPLParser(const OPLParser&) = delete;
+                OPLParser& operator=(const OPLParser&) = delete;
+
+                OPLParser(OPLParser&&) = delete;
+                OPLParser& operator=(OPLParser&&) = delete;
+
                 ~OPLParser() noexcept final = default;
 
                 void parse_line(const char* data) {
diff --git a/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp
index d1fb2e501ca..f61fba714b7 100644
--- a/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <iterator>
-#include <memory>
-#include <string>
-#include <utility>
-
 #include <osmium/io/detail/output_format.hpp>
 #include <osmium/io/detail/queue_util.hpp>
 #include <osmium/io/detail/string_util.hpp>
@@ -51,6 +45,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/changeset.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
+#include <osmium/osm/metadata_options.hpp>
 #include <osmium/osm/node.hpp>
 #include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/object.hpp>
@@ -61,6 +56,12 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/thread/pool.hpp>
 #include <osmium/visitor.hpp>
 
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace io {
@@ -69,16 +70,16 @@ namespace osmium {
 
             struct opl_output_options {
 
-                /// Should metadata of objects be added?
-                bool add_metadata;
+                /// Which metadata of objects should be added?
+                osmium::metadata_options add_metadata;
 
                 /// Should node locations be added to ways?
-                bool locations_on_ways;
+                bool locations_on_ways = false;
 
                 /// Write in form of a diff file?
-                bool format_as_diff;
+                bool format_as_diff = false;
 
-            };
+            }; // struct opl_output_options
 
             /**
              * Writes out one buffer with OSM data in OPL format.
@@ -123,19 +124,29 @@ namespace osmium {
 
                 void write_meta(const osmium::OSMObject& object) {
                     output_int(object.id());
-                    if (m_options.add_metadata) {
-                        *m_out += ' ';
-                        write_field_int('v', object.version());
+                    if (m_options.add_metadata.any()) {
+                        if (m_options.add_metadata.version()) {
+                            *m_out += ' ';
+                            write_field_int('v', object.version());
+                        }
                         *m_out += " d";
                         *m_out += (object.visible() ? 'V' : 'D');
-                        *m_out += ' ';
-                        write_field_int('c', object.changeset());
-                        *m_out += ' ';
-                        write_field_timestamp('t', object.timestamp());
-                        *m_out += ' ';
-                        write_field_int('i', object.uid());
-                        *m_out += " u";
-                        append_encoded_string(object.user());
+                        if (m_options.add_metadata.changeset()) {
+                            *m_out += ' ';
+                            write_field_int('c', object.changeset());
+                        }
+                        if (m_options.add_metadata.timestamp()) {
+                            *m_out += ' ';
+                            write_field_timestamp('t', object.timestamp());
+                        }
+                        if (m_options.add_metadata.uid()) {
+                            *m_out += ' ';
+                            write_field_int('i', object.uid());
+                        }
+                        if (m_options.add_metadata.user()) {
+                            *m_out += " u";
+                            append_encoded_string(object.user());
+                        }
                     }
                     write_tags(object.tags());
                 }
@@ -167,14 +178,6 @@ namespace osmium {
                     m_options(options) {
                 }
 
-                OPLOutputBlock(const OPLOutputBlock&) = default;
-                OPLOutputBlock& operator=(const OPLOutputBlock&) = default;
-
-                OPLOutputBlock(OPLOutputBlock&&) = default;
-                OPLOutputBlock& operator=(OPLOutputBlock&&) = default;
-
-                ~OPLOutputBlock() noexcept = default;
-
                 std::string operator()() {
                     osmium::apply(m_input_buffer->cbegin(), m_input_buffer->cend(), *this);
 
@@ -285,18 +288,12 @@ namespace osmium {
             public:
 
                 OPLOutputFormat(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) :
-                    OutputFormat(pool, output_queue),
-                    m_options() {
-                    m_options.add_metadata      = file.is_not_false("add_metadata");
+                    OutputFormat(pool, output_queue) {
+                    m_options.add_metadata      = osmium::metadata_options{file.get("add_metadata")};
                     m_options.locations_on_ways = file.is_true("locations_on_ways");
                     m_options.format_as_diff    = file.is_true("diff");
                 }
 
-                OPLOutputFormat(const OPLOutputFormat&) = delete;
-                OPLOutputFormat& operator=(const OPLOutputFormat&) = delete;
-
-                ~OPLOutputFormat() noexcept final = default;
-
                 void write_buffer(osmium::memory::Buffer&& buffer) final {
                     m_output_queue.push(m_pool.submit(OPLOutputBlock{std::move(buffer), m_options}));
                 }
diff --git a/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp b/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp
index f21145b67aa..935455e662d 100644
--- a/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <cstdlib>
-#include <iterator>
-#include <limits>
-#include <stdexcept>
-#include <string>
-
-#include <utf8.h>
-
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/io/error.hpp>
 #include <osmium/memory/buffer.hpp>
@@ -56,6 +47,15 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 
+#include <utf8.h>
+
+#include <cstdint>
+#include <cstdlib>
+#include <iterator>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
 namespace osmium {
 
     namespace builder {
@@ -187,7 +187,8 @@ namespace osmium {
                 while (true) {
                     if (*s == '\0' || *s == ' ' || *s == '\t' || *s == ',' || *s == '=') {
                         break;
-                    } else if (*s == '%') {
+                    }
+                    if (*s == '%') {
                         ++s;
                         opl_parse_escaped(&s, result);
                     } else {
diff --git a/third_party/libosmium/include/osmium/io/detail/output_format.hpp b/third_party/libosmium/include/osmium/io/detail/output_format.hpp
index 21d5e86eb83..43c28755f6a 100644
--- a/third_party/libosmium/include/osmium/io/detail/output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/output_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,13 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <functional>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-
 #include <osmium/handler.hpp>
 #include <osmium/io/detail/queue_util.hpp>
 #include <osmium/io/error.hpp>
@@ -48,6 +41,13 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/memory/buffer.hpp>
 #include <osmium/thread/pool.hpp>
 
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace io {
@@ -121,23 +121,23 @@ namespace osmium {
 
             public:
 
-                OutputFormat(osmium::thread::Pool& pool, future_string_queue_type& output_queue) :
+                OutputFormat(osmium::thread::Pool& pool, future_string_queue_type& output_queue) noexcept :
                     m_pool(pool),
                     m_output_queue(output_queue) {
                 }
 
                 OutputFormat(const OutputFormat&) = delete;
-                OutputFormat(OutputFormat&&) = delete;
-
                 OutputFormat& operator=(const OutputFormat&) = delete;
+
+                OutputFormat(OutputFormat&&) = delete;
                 OutputFormat& operator=(OutputFormat&&) = delete;
 
                 virtual ~OutputFormat() noexcept = default;
 
-                virtual void write_header(const osmium::io::Header&) {
+                virtual void write_header(const osmium::io::Header& /*header*/) {
                 }
 
-                virtual void write_buffer(osmium::memory::Buffer&&) = 0;
+                virtual void write_buffer(osmium::memory::Buffer&& /*buffer*/) = 0;
 
                 virtual void write_end() {
                 }
@@ -159,32 +159,34 @@ namespace osmium {
 
             private:
 
-                using map_type = std::map<osmium::io::file_format, create_output_type>;
+                std::array<create_output_type, static_cast<std::size_t>(file_format::last) + 1> m_callbacks;
+
+                OutputFormatFactory() noexcept = default;
 
-                map_type m_callbacks;
+                create_output_type& callbacks(const osmium::io::file_format format) noexcept {
+                    return m_callbacks[static_cast<std::size_t>(format)];
+                }
 
-                OutputFormatFactory() :
-                    m_callbacks() {
+                const create_output_type& callbacks(const osmium::io::file_format format) const noexcept {
+                    return m_callbacks[static_cast<std::size_t>(format)];
                 }
 
             public:
 
-                static OutputFormatFactory& instance() {
+                static OutputFormatFactory& instance() noexcept {
                     static OutputFormatFactory factory;
                     return factory;
                 }
 
-                bool register_output_format(osmium::io::file_format format, create_output_type create_function) {
-                    if (! m_callbacks.insert(map_type::value_type(format, create_function)).second) {
-                        return false;
-                    }
+                bool register_output_format(const osmium::io::file_format format, create_output_type&& create_function) {
+                    callbacks(format) = std::forward<create_output_type>(create_function);
                     return true;
                 }
 
-                std::unique_ptr<osmium::io::detail::OutputFormat> create_output(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) {
-                    const auto it = m_callbacks.find(file.format());
-                    if (it != m_callbacks.end()) {
-                        return std::unique_ptr<osmium::io::detail::OutputFormat>((it->second)(pool, file, output_queue));
+                std::unique_ptr<osmium::io::detail::OutputFormat> create_output(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) const {
+                    const auto func = callbacks(file.format());
+                    if (func) {
+                        return std::unique_ptr<osmium::io::detail::OutputFormat>((func)(pool, file, output_queue));
                     }
 
                     throw unsupported_file_format_error{
@@ -208,6 +210,9 @@ namespace osmium {
                 BlackholeOutputFormat(const BlackholeOutputFormat&) = delete;
                 BlackholeOutputFormat& operator=(const BlackholeOutputFormat&) = delete;
 
+                BlackholeOutputFormat(BlackholeOutputFormat&&) = delete;
+                BlackholeOutputFormat& operator=(BlackholeOutputFormat&&) = delete;
+
                 ~BlackholeOutputFormat() noexcept final = default;
 
                 void write_buffer(osmium::memory::Buffer&& /*buffer*/) final {
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf.hpp b/third_party/libosmium/include/osmium/io/detail/pbf.hpp
index acd1fc4f101..c2b2681dae8 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,18 +33,18 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <string>
+#include <osmium/io/error.hpp>
+#include <osmium/osm/location.hpp>
 
-// needed for htonl and ntohl
+// needed for htonl and ntohl or their equivalent in protozero
 #ifndef _WIN32
 # include <netinet/in.h>
 #else
-# include <winsock2.h>
+# include <protozero/byteswap.hpp>
 #endif
 
-#include <osmium/io/error.hpp>
-#include <osmium/osm/location.hpp>
+#include <cstdint>
+#include <string>
 
 namespace osmium {
 
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp b/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp
index 6b0530124fc..b63893b63fd 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,19 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <protozero/iterators.hpp>
-#include <protozero/pbf_message.hpp>
-#include <protozero/types.hpp>
-
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
 #include <osmium/io/detail/protobuf_tags.hpp>
@@ -63,9 +50,21 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
-#include <osmium/util/cast.hpp>
 #include <osmium/util/delta.hpp>
 
+#include <protozero/iterators.hpp>
+#include <protozero/pbf_message.hpp>
+#include <protozero/types.hpp>
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
 namespace osmium {
 
     namespace builder {
@@ -103,7 +102,7 @@ namespace osmium {
                     }
 
                     protozero::pbf_message<OSMFormat::StringTable> pbf_string_table{data};
-                    while (pbf_string_table.next(OSMFormat::StringTable::repeated_bytes_s)) {
+                    while (pbf_string_table.next(OSMFormat::StringTable::repeated_bytes_s, protozero::pbf_wire_type::length_delimited)) {
                         const auto str_view = pbf_string_table.get_view();
                         if (str_view.size() > osmium::max_osm_string_length) {
                             throw osmium::pbf_error{"overlong string in string table"};
@@ -115,20 +114,20 @@ namespace osmium {
                 void decode_primitive_block_metadata() {
                     protozero::pbf_message<OSMFormat::PrimitiveBlock> pbf_primitive_block{m_data};
                     while (pbf_primitive_block.next()) {
-                        switch (pbf_primitive_block.tag()) {
-                            case OSMFormat::PrimitiveBlock::required_StringTable_stringtable:
+                        switch (pbf_primitive_block.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::PrimitiveBlock::required_StringTable_stringtable, protozero::pbf_wire_type::length_delimited):
                                 decode_stringtable(pbf_primitive_block.get_view());
                                 break;
-                            case OSMFormat::PrimitiveBlock::optional_int32_granularity:
+                            case protozero::tag_and_type(OSMFormat::PrimitiveBlock::optional_int32_granularity, protozero::pbf_wire_type::varint):
                                 m_granularity = pbf_primitive_block.get_int32();
                                 break;
-                            case OSMFormat::PrimitiveBlock::optional_int32_date_granularity:
+                            case protozero::tag_and_type(OSMFormat::PrimitiveBlock::optional_int32_date_granularity, protozero::pbf_wire_type::varint):
                                 m_date_factor = pbf_primitive_block.get_int32();
                                 break;
-                            case OSMFormat::PrimitiveBlock::optional_int64_lat_offset:
+                            case protozero::tag_and_type(OSMFormat::PrimitiveBlock::optional_int64_lat_offset, protozero::pbf_wire_type::varint):
                                 m_lat_offset = pbf_primitive_block.get_int64();
                                 break;
-                            case OSMFormat::PrimitiveBlock::optional_int64_lon_offset:
+                            case protozero::tag_and_type(OSMFormat::PrimitiveBlock::optional_int64_lon_offset, protozero::pbf_wire_type::varint):
                                 m_lon_offset = pbf_primitive_block.get_int64();
                                 break;
                             default:
@@ -139,11 +138,11 @@ namespace osmium {
 
                 void decode_primitive_block_data() {
                     protozero::pbf_message<OSMFormat::PrimitiveBlock> pbf_primitive_block{m_data};
-                    while (pbf_primitive_block.next(OSMFormat::PrimitiveBlock::repeated_PrimitiveGroup_primitivegroup)) {
+                    while (pbf_primitive_block.next(OSMFormat::PrimitiveBlock::repeated_PrimitiveGroup_primitivegroup, protozero::pbf_wire_type::length_delimited)) {
                         protozero::pbf_message<OSMFormat::PrimitiveGroup> pbf_primitive_group = pbf_primitive_block.get_message();
                         while (pbf_primitive_group.next()) {
-                            switch (pbf_primitive_group.tag()) {
-                                case OSMFormat::PrimitiveGroup::repeated_Node_nodes:
+                            switch (pbf_primitive_group.tag_and_type()) {
+                                case protozero::tag_and_type(OSMFormat::PrimitiveGroup::repeated_Node_nodes, protozero::pbf_wire_type::length_delimited):
                                     if (m_read_types & osmium::osm_entity_bits::node) {
                                         decode_node(pbf_primitive_group.get_view());
                                         m_buffer.commit();
@@ -151,7 +150,7 @@ namespace osmium {
                                         pbf_primitive_group.skip();
                                     }
                                     break;
-                                case OSMFormat::PrimitiveGroup::optional_DenseNodes_dense:
+                                case protozero::tag_and_type(OSMFormat::PrimitiveGroup::optional_DenseNodes_dense, protozero::pbf_wire_type::length_delimited):
                                     if (m_read_types & osmium::osm_entity_bits::node) {
                                         if (m_read_metadata == osmium::io::read_meta::yes) {
                                             decode_dense_nodes(pbf_primitive_group.get_view());
@@ -163,7 +162,7 @@ namespace osmium {
                                         pbf_primitive_group.skip();
                                     }
                                     break;
-                                case OSMFormat::PrimitiveGroup::repeated_Way_ways:
+                                case protozero::tag_and_type(OSMFormat::PrimitiveGroup::repeated_Way_ways, protozero::pbf_wire_type::length_delimited):
                                     if (m_read_types & osmium::osm_entity_bits::way) {
                                         decode_way(pbf_primitive_group.get_view());
                                         m_buffer.commit();
@@ -171,7 +170,7 @@ namespace osmium {
                                         pbf_primitive_group.skip();
                                     }
                                     break;
-                                case OSMFormat::PrimitiveGroup::repeated_Relation_relations:
+                                case protozero::tag_and_type(OSMFormat::PrimitiveGroup::repeated_Relation_relations, protozero::pbf_wire_type::length_delimited):
                                     if (m_read_types & osmium::osm_entity_bits::relation) {
                                         decode_relation(pbf_primitive_group.get_view());
                                         m_buffer.commit();
@@ -191,35 +190,45 @@ namespace osmium {
 
                     protozero::pbf_message<OSMFormat::Info> pbf_info{data};
                     while (pbf_info.next()) {
-                        switch (pbf_info.tag()) {
-                            case OSMFormat::Info::optional_int32_version:
+                        switch (pbf_info.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::Info::optional_int32_version, protozero::pbf_wire_type::varint):
                                 {
                                     const auto version = pbf_info.get_int32();
-                                    if (version < 0) {
+                                    if (version < -1) {
                                         throw osmium::pbf_error{"object version must not be negative"};
                                     }
-                                    object.set_version(static_cast_with_assert<object_version_type>(version));
+
+                                    if (version == -1) {
+                                        object.set_version(0U);
+                                    } else {
+                                        object.set_version(static_cast<object_version_type>(version));
+                                    }
                                 }
                                 break;
-                            case OSMFormat::Info::optional_int64_timestamp:
+                            case protozero::tag_and_type(OSMFormat::Info::optional_int64_timestamp, protozero::pbf_wire_type::varint):
                                 object.set_timestamp(pbf_info.get_int64() * m_date_factor / 1000);
                                 break;
-                            case OSMFormat::Info::optional_int64_changeset:
+                            case protozero::tag_and_type(OSMFormat::Info::optional_int64_changeset, protozero::pbf_wire_type::varint):
                                 {
                                     const auto changeset_id = pbf_info.get_int64();
-                                    if (changeset_id < 0) {
-                                        throw osmium::pbf_error{"object changeset_id must not be negative"};
+                                    if (changeset_id < -1 || changeset_id >= std::numeric_limits<changeset_id_type>::max()) {
+                                        throw osmium::pbf_error{"object changeset_id must be between 0 and 2^32-1"};
+                                    }
+
+                                    if (changeset_id == -1) {
+                                        object.set_changeset(0U);
+                                    } else {
+                                        object.set_changeset(static_cast<changeset_id_type>(changeset_id));
                                     }
-                                    object.set_changeset(static_cast_with_assert<changeset_id_type>(changeset_id));
                                 }
                                 break;
-                            case OSMFormat::Info::optional_int32_uid:
+                            case protozero::tag_and_type(OSMFormat::Info::optional_int32_uid, protozero::pbf_wire_type::varint):
                                 object.set_uid_from_signed(pbf_info.get_int32());
                                 break;
-                            case OSMFormat::Info::optional_uint32_user_sid:
+                            case protozero::tag_and_type(OSMFormat::Info::optional_uint32_user_sid, protozero::pbf_wire_type::varint):
                                 user = m_stringtable.at(pbf_info.get_uint32());
                                 break;
-                            case OSMFormat::Info::optional_bool_visible:
+                            case protozero::tag_and_type(OSMFormat::Info::optional_bool_visible, protozero::pbf_wire_type::varint):
                                 object.set_visible(pbf_info.get_bool());
                                 break;
                             default:
@@ -249,7 +258,7 @@ namespace osmium {
                     }
                 }
 
-                int32_t convert_pbf_coordinate(int64_t c) const {
+                int32_t convert_pbf_coordinate(int64_t c) const noexcept {
                     return int32_t((c * m_granularity + m_lon_offset) / resolution_convert);
                 }
 
@@ -266,27 +275,27 @@ namespace osmium {
 
                     protozero::pbf_message<OSMFormat::Node> pbf_node{data};
                     while (pbf_node.next()) {
-                        switch (pbf_node.tag()) {
-                            case OSMFormat::Node::required_sint64_id:
+                        switch (pbf_node.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::Node::required_sint64_id, protozero::pbf_wire_type::varint):
                                 node.set_id(pbf_node.get_sint64());
                                 break;
-                            case OSMFormat::Node::packed_uint32_keys:
+                            case protozero::tag_and_type(OSMFormat::Node::packed_uint32_keys, protozero::pbf_wire_type::length_delimited):
                                 keys = pbf_node.get_packed_uint32();
                                 break;
-                            case OSMFormat::Node::packed_uint32_vals:
+                            case protozero::tag_and_type(OSMFormat::Node::packed_uint32_vals, protozero::pbf_wire_type::length_delimited):
                                 vals = pbf_node.get_packed_uint32();
                                 break;
-                            case OSMFormat::Node::optional_Info_info:
+                            case protozero::tag_and_type(OSMFormat::Node::optional_Info_info, protozero::pbf_wire_type::length_delimited):
                                 if (m_read_metadata == osmium::io::read_meta::yes) {
                                     user = decode_info(pbf_node.get_view(), builder.object());
                                 } else {
                                     pbf_node.skip();
                                 }
                                 break;
-                            case OSMFormat::Node::required_sint64_lat:
+                            case protozero::tag_and_type(OSMFormat::Node::required_sint64_lat, protozero::pbf_wire_type::varint):
                                 lat = pbf_node.get_sint64();
                                 break;
-                            case OSMFormat::Node::required_sint64_lon:
+                            case protozero::tag_and_type(OSMFormat::Node::required_sint64_lon, protozero::pbf_wire_type::varint):
                                 lon = pbf_node.get_sint64();
                                 break;
                             default:
@@ -323,30 +332,30 @@ namespace osmium {
 
                     protozero::pbf_message<OSMFormat::Way> pbf_way{data};
                     while (pbf_way.next()) {
-                        switch (pbf_way.tag()) {
-                            case OSMFormat::Way::required_int64_id:
+                        switch (pbf_way.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::Way::required_int64_id, protozero::pbf_wire_type::varint):
                                 builder.object().set_id(pbf_way.get_int64());
                                 break;
-                            case OSMFormat::Way::packed_uint32_keys:
+                            case protozero::tag_and_type(OSMFormat::Way::packed_uint32_keys, protozero::pbf_wire_type::length_delimited):
                                 keys = pbf_way.get_packed_uint32();
                                 break;
-                            case OSMFormat::Way::packed_uint32_vals:
+                            case protozero::tag_and_type(OSMFormat::Way::packed_uint32_vals, protozero::pbf_wire_type::length_delimited):
                                 vals = pbf_way.get_packed_uint32();
                                 break;
-                            case OSMFormat::Way::optional_Info_info:
+                            case protozero::tag_and_type(OSMFormat::Way::optional_Info_info, protozero::pbf_wire_type::length_delimited):
                                 if (m_read_metadata == osmium::io::read_meta::yes) {
                                     user = decode_info(pbf_way.get_view(), builder.object());
                                 } else {
                                     pbf_way.skip();
                                 }
                                 break;
-                            case OSMFormat::Way::packed_sint64_refs:
+                            case protozero::tag_and_type(OSMFormat::Way::packed_sint64_refs, protozero::pbf_wire_type::length_delimited):
                                 refs = pbf_way.get_packed_sint64();
                                 break;
-                            case OSMFormat::Way::packed_sint64_lat:
+                            case protozero::tag_and_type(OSMFormat::Way::packed_sint64_lat, protozero::pbf_wire_type::length_delimited):
                                 lats = pbf_way.get_packed_sint64();
                                 break;
-                            case OSMFormat::Way::packed_sint64_lon:
+                            case protozero::tag_and_type(OSMFormat::Way::packed_sint64_lon, protozero::pbf_wire_type::length_delimited):
                                 lons = pbf_way.get_packed_sint64();
                                 break;
                             default:
@@ -358,14 +367,14 @@ namespace osmium {
 
                     if (!refs.empty()) {
                         osmium::builder::WayNodeListBuilder wnl_builder{builder};
-                        osmium::util::DeltaDecode<int64_t> ref;
+                        osmium::DeltaDecode<int64_t> ref;
                         if (lats.empty()) {
                             for (const auto& ref_value : refs) {
                                 wnl_builder.add_node_ref(ref.update(ref_value));
                             }
                         } else {
-                            osmium::util::DeltaDecode<int64_t> lon;
-                            osmium::util::DeltaDecode<int64_t> lat;
+                            osmium::DeltaDecode<int64_t> lon;
+                            osmium::DeltaDecode<int64_t> lat;
                             while (!refs.empty() && !lons.empty() && !lats.empty()) {
                                 wnl_builder.add_node_ref(
                                     ref.update(refs.front()),
@@ -395,30 +404,30 @@ namespace osmium {
 
                     protozero::pbf_message<OSMFormat::Relation> pbf_relation{data};
                     while (pbf_relation.next()) {
-                        switch (pbf_relation.tag()) {
-                            case OSMFormat::Relation::required_int64_id:
+                        switch (pbf_relation.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::Relation::required_int64_id, protozero::pbf_wire_type::varint):
                                 builder.object().set_id(pbf_relation.get_int64());
                                 break;
-                            case OSMFormat::Relation::packed_uint32_keys:
+                            case protozero::tag_and_type(OSMFormat::Relation::packed_uint32_keys, protozero::pbf_wire_type::length_delimited):
                                 keys = pbf_relation.get_packed_uint32();
                                 break;
-                            case OSMFormat::Relation::packed_uint32_vals:
+                            case protozero::tag_and_type(OSMFormat::Relation::packed_uint32_vals, protozero::pbf_wire_type::length_delimited):
                                 vals = pbf_relation.get_packed_uint32();
                                 break;
-                            case OSMFormat::Relation::optional_Info_info:
+                            case protozero::tag_and_type(OSMFormat::Relation::optional_Info_info, protozero::pbf_wire_type::length_delimited):
                                 if (m_read_metadata == osmium::io::read_meta::yes) {
                                     user = decode_info(pbf_relation.get_view(), builder.object());
                                 } else {
                                     pbf_relation.skip();
                                 }
                                 break;
-                            case OSMFormat::Relation::packed_int32_roles_sid:
+                            case protozero::tag_and_type(OSMFormat::Relation::packed_int32_roles_sid, protozero::pbf_wire_type::length_delimited):
                                 roles = pbf_relation.get_packed_int32();
                                 break;
-                            case OSMFormat::Relation::packed_sint64_memids:
+                            case protozero::tag_and_type(OSMFormat::Relation::packed_sint64_memids, protozero::pbf_wire_type::length_delimited):
                                 refs = pbf_relation.get_packed_sint64();
                                 break;
-                            case OSMFormat::Relation::packed_MemberType_types:
+                            case protozero::tag_and_type(OSMFormat::Relation::packed_MemberType_types, protozero::pbf_wire_type::length_delimited):
                                 types = pbf_relation.get_packed_enum();
                                 break;
                             default:
@@ -430,7 +439,7 @@ namespace osmium {
 
                     if (!refs.empty()) {
                         osmium::builder::RelationMemberListBuilder rml_builder{builder};
-                        osmium::util::DeltaDecode<int64_t> ref;
+                        osmium::DeltaDecode<int64_t> ref;
                         while (!roles.empty() && !refs.empty() && !types.empty()) {
                             const auto& r = m_stringtable.at(roles.front());
                             const int type = types.front();
@@ -477,17 +486,17 @@ namespace osmium {
 
                     protozero::pbf_message<OSMFormat::DenseNodes> pbf_dense_nodes{data};
                     while (pbf_dense_nodes.next()) {
-                        switch (pbf_dense_nodes.tag()) {
-                            case OSMFormat::DenseNodes::packed_sint64_id:
+                        switch (pbf_dense_nodes.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_id, protozero::pbf_wire_type::length_delimited):
                                 ids = pbf_dense_nodes.get_packed_sint64();
                                 break;
-                            case OSMFormat::DenseNodes::packed_sint64_lat:
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lat, protozero::pbf_wire_type::length_delimited):
                                 lats = pbf_dense_nodes.get_packed_sint64();
                                 break;
-                            case OSMFormat::DenseNodes::packed_sint64_lon:
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lon, protozero::pbf_wire_type::length_delimited):
                                 lons = pbf_dense_nodes.get_packed_sint64();
                                 break;
-                            case OSMFormat::DenseNodes::packed_int32_keys_vals:
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_int32_keys_vals, protozero::pbf_wire_type::length_delimited):
                                 tags = pbf_dense_nodes.get_packed_int32();
                                 break;
                             default:
@@ -495,9 +504,9 @@ namespace osmium {
                         }
                     }
 
-                    osmium::util::DeltaDecode<int64_t> dense_id;
-                    osmium::util::DeltaDecode<int64_t> dense_latitude;
-                    osmium::util::DeltaDecode<int64_t> dense_longitude;
+                    osmium::DeltaDecode<int64_t> dense_id;
+                    osmium::DeltaDecode<int64_t> dense_latitude;
+                    osmium::DeltaDecode<int64_t> dense_longitude;
 
                     auto tag_it = tags.begin();
 
@@ -531,8 +540,7 @@ namespace osmium {
                 }
 
                 void decode_dense_nodes(const data_view& data) {
-                    bool has_info     = false;
-                    bool has_visibles = false;
+                    bool has_info = false;
 
                     protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> ids;
                     protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> lats;
@@ -549,33 +557,32 @@ namespace osmium {
 
                     protozero::pbf_message<OSMFormat::DenseNodes> pbf_dense_nodes{data};
                     while (pbf_dense_nodes.next()) {
-                        switch (pbf_dense_nodes.tag()) {
-                            case OSMFormat::DenseNodes::packed_sint64_id:
+                        switch (pbf_dense_nodes.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_id, protozero::pbf_wire_type::length_delimited):
                                 ids = pbf_dense_nodes.get_packed_sint64();
                                 break;
-                            case OSMFormat::DenseNodes::optional_DenseInfo_denseinfo:
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::optional_DenseInfo_denseinfo, protozero::pbf_wire_type::length_delimited):
                                 {
                                     has_info = true;
                                     protozero::pbf_message<OSMFormat::DenseInfo> pbf_dense_info{pbf_dense_nodes.get_message()};
                                     while (pbf_dense_info.next()) {
-                                        switch (pbf_dense_info.tag()) {
-                                            case OSMFormat::DenseInfo::packed_int32_version:
+                                        switch (pbf_dense_info.tag_and_type()) {
+                                            case protozero::tag_and_type(OSMFormat::DenseInfo::packed_int32_version, protozero::pbf_wire_type::length_delimited):
                                                 versions = pbf_dense_info.get_packed_int32();
                                                 break;
-                                            case OSMFormat::DenseInfo::packed_sint64_timestamp:
+                                            case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint64_timestamp, protozero::pbf_wire_type::length_delimited):
                                                 timestamps = pbf_dense_info.get_packed_sint64();
                                                 break;
-                                            case OSMFormat::DenseInfo::packed_sint64_changeset:
+                                            case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint64_changeset, protozero::pbf_wire_type::length_delimited):
                                                 changesets = pbf_dense_info.get_packed_sint64();
                                                 break;
-                                            case OSMFormat::DenseInfo::packed_sint32_uid:
+                                            case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint32_uid, protozero::pbf_wire_type::length_delimited):
                                                 uids = pbf_dense_info.get_packed_sint32();
                                                 break;
-                                            case OSMFormat::DenseInfo::packed_sint32_user_sid:
+                                            case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint32_user_sid, protozero::pbf_wire_type::length_delimited):
                                                 user_sids = pbf_dense_info.get_packed_sint32();
                                                 break;
-                                            case OSMFormat::DenseInfo::packed_bool_visible:
-                                                has_visibles = true;
+                                            case protozero::tag_and_type(OSMFormat::DenseInfo::packed_bool_visible, protozero::pbf_wire_type::length_delimited):
                                                 visibles = pbf_dense_info.get_packed_bool();
                                                 break;
                                             default:
@@ -584,13 +591,13 @@ namespace osmium {
                                     }
                                 }
                                 break;
-                            case OSMFormat::DenseNodes::packed_sint64_lat:
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lat, protozero::pbf_wire_type::length_delimited):
                                 lats = pbf_dense_nodes.get_packed_sint64();
                                 break;
-                            case OSMFormat::DenseNodes::packed_sint64_lon:
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lon, protozero::pbf_wire_type::length_delimited):
                                 lons = pbf_dense_nodes.get_packed_sint64();
                                 break;
-                            case OSMFormat::DenseNodes::packed_int32_keys_vals:
+                            case protozero::tag_and_type(OSMFormat::DenseNodes::packed_int32_keys_vals, protozero::pbf_wire_type::length_delimited):
                                 tags = pbf_dense_nodes.get_packed_int32();
                                 break;
                             default:
@@ -598,13 +605,13 @@ namespace osmium {
                         }
                     }
 
-                    osmium::util::DeltaDecode<int64_t> dense_id;
-                    osmium::util::DeltaDecode<int64_t> dense_latitude;
-                    osmium::util::DeltaDecode<int64_t> dense_longitude;
-                    osmium::util::DeltaDecode<int64_t> dense_uid;
-                    osmium::util::DeltaDecode<int64_t> dense_user_sid;
-                    osmium::util::DeltaDecode<int64_t> dense_changeset;
-                    osmium::util::DeltaDecode<int64_t> dense_timestamp;
+                    osmium::DeltaDecode<int64_t> dense_id;
+                    osmium::DeltaDecode<int64_t> dense_latitude;
+                    osmium::DeltaDecode<int64_t> dense_longitude;
+                    osmium::DeltaDecode<int64_t> dense_uid;
+                    osmium::DeltaDecode<int64_t> dense_user_sid;
+                    osmium::DeltaDecode<int64_t> dense_changeset;
+                    osmium::DeltaDecode<int64_t> dense_timestamp;
 
                     auto tag_it = tags.begin();
 
@@ -624,47 +631,55 @@ namespace osmium {
                         ids.drop_front();
 
                         if (has_info) {
-                            if (versions.empty() ||
-                                changesets.empty() ||
-                                timestamps.empty() ||
-                                uids.empty() ||
-                                user_sids.empty()) {
-                                // this is against the spec, must have same number of elements
-                                throw osmium::pbf_error{"PBF format error"};
+                            if (!versions.empty()) {
+                                const auto version = versions.front();
+                                versions.drop_front();
+                                if (version < -1) {
+                                    throw osmium::pbf_error{"object version must not be negative"};
+                                }
+
+                                if (version == -1) {
+                                    node.set_version(0U);
+                                } else {
+                                    node.set_version(static_cast<osmium::object_version_type>(version));
+                                }
                             }
 
-                            const auto version = versions.front();
-                            versions.drop_front();
-                            if (version < 0) {
-                                throw osmium::pbf_error{"object version must not be negative"};
+                            if (!changesets.empty()) {
+                                const auto changeset_id = dense_changeset.update(changesets.front());
+                                changesets.drop_front();
+                                if (changeset_id < -1 || changeset_id >= std::numeric_limits<changeset_id_type>::max()) {
+                                    throw osmium::pbf_error{"object changeset_id must be between 0 and 2^32-1"};
+                                }
+
+                                if (changeset_id == -1) {
+                                    node.set_changeset(0U);
+                                } else {
+                                    node.set_changeset(static_cast<osmium::changeset_id_type>(changeset_id));
+                                }
                             }
-                            node.set_version(static_cast<osmium::object_version_type>(version));
 
-                            const auto changeset_id = dense_changeset.update(changesets.front());
-                            changesets.drop_front();
-                            if (changeset_id < 0) {
-                                throw osmium::pbf_error{"object changeset_id must not be negative"};
+                            if (!timestamps.empty()) {
+                                node.set_timestamp(dense_timestamp.update(timestamps.front()) * m_date_factor / 1000);
+                                timestamps.drop_front();
                             }
-                            node.set_changeset(static_cast<osmium::changeset_id_type>(changeset_id));
 
-                            node.set_timestamp(dense_timestamp.update(timestamps.front()) * m_date_factor / 1000);
-                            timestamps.drop_front();
-                            node.set_uid_from_signed(static_cast<osmium::signed_user_id_type>(dense_uid.update(uids.front())));
-                            uids.drop_front();
+                            if (!uids.empty()) {
+                                node.set_uid_from_signed(static_cast<osmium::signed_user_id_type>(dense_uid.update(uids.front())));
+                                uids.drop_front();
+                            }
 
-                            if (has_visibles) {
-                                if (visibles.empty()) {
-                                    // this is against the spec, must have same number of elements
-                                    throw osmium::pbf_error{"PBF format error"};
-                                }
+                            if (!visibles.empty()) {
                                 visible = (visibles.front() != 0);
                                 visibles.drop_front();
                             }
                             node.set_visible(visible);
 
-                            const auto& u = m_stringtable.at(dense_user_sid.update(user_sids.front()));
-                            user_sids.drop_front();
-                            builder.set_user(u.first, u.second);
+                            if (!user_sids.empty()) {
+                                const auto& u = m_stringtable.at(dense_user_sid.update(user_sids.front()));
+                                user_sids.drop_front();
+                                builder.set_user(u.first, u.second);
+                            }
                         }
 
                         // even if the node isn't visible, there's still a record
@@ -722,8 +737,8 @@ namespace osmium {
 
                 protozero::pbf_message<FileFormat::Blob> pbf_blob{blob_data};
                 while (pbf_blob.next()) {
-                    switch (pbf_blob.tag()) {
-                        case FileFormat::Blob::optional_bytes_raw:
+                    switch (pbf_blob.tag_and_type()) {
+                        case protozero::tag_and_type(FileFormat::Blob::optional_bytes_raw, protozero::pbf_wire_type::length_delimited):
                             {
                                 const auto data_len = pbf_blob.get_view();
                                 if (data_len.size() > max_uncompressed_blob_size) {
@@ -731,27 +746,27 @@ namespace osmium {
                                 }
                                 return data_len;
                             }
-                        case FileFormat::Blob::optional_int32_raw_size:
+                        case protozero::tag_and_type(FileFormat::Blob::optional_int32_raw_size, protozero::pbf_wire_type::varint):
                             raw_size = pbf_blob.get_int32();
                             if (raw_size <= 0 || uint32_t(raw_size) > max_uncompressed_blob_size) {
                                 throw osmium::pbf_error{"illegal blob size"};
                             }
                             break;
-                        case FileFormat::Blob::optional_bytes_zlib_data:
+                        case protozero::tag_and_type(FileFormat::Blob::optional_bytes_zlib_data, protozero::pbf_wire_type::length_delimited):
                             zlib_data = pbf_blob.get_view();
                             break;
-                        case FileFormat::Blob::optional_bytes_lzma_data:
+                        case protozero::tag_and_type(FileFormat::Blob::optional_bytes_lzma_data, protozero::pbf_wire_type::length_delimited):
                             throw osmium::pbf_error{"lzma blobs not implemented"};
                         default:
                             throw osmium::pbf_error{"unknown compression"};
                     }
                 }
 
-                if (zlib_data.size() != 0 && raw_size != 0) {
+                if (!zlib_data.empty() && raw_size != 0) {
                     return osmium::io::detail::zlib_uncompress_string(
                         zlib_data.data(),
-                        static_cast<unsigned long>(zlib_data.size()),
-                        static_cast<unsigned long>(raw_size),
+                        static_cast<unsigned long>(zlib_data.size()), // NOLINT(google-runtime-int)
+                        static_cast<unsigned long>(raw_size), // NOLINT(google-runtime-int)
                         output
                     );
                 }
@@ -767,17 +782,17 @@ namespace osmium {
 
                     protozero::pbf_message<OSMFormat::HeaderBBox> pbf_header_bbox{data};
                     while (pbf_header_bbox.next()) {
-                        switch (pbf_header_bbox.tag()) {
-                            case OSMFormat::HeaderBBox::required_sint64_left:
+                        switch (pbf_header_bbox.tag_and_type()) {
+                            case protozero::tag_and_type(OSMFormat::HeaderBBox::required_sint64_left, protozero::pbf_wire_type::varint):
                                 left = pbf_header_bbox.get_sint64();
                                 break;
-                            case OSMFormat::HeaderBBox::required_sint64_right:
+                            case protozero::tag_and_type(OSMFormat::HeaderBBox::required_sint64_right, protozero::pbf_wire_type::varint):
                                 right = pbf_header_bbox.get_sint64();
                                 break;
-                            case OSMFormat::HeaderBBox::required_sint64_top:
+                            case protozero::tag_and_type(OSMFormat::HeaderBBox::required_sint64_top, protozero::pbf_wire_type::varint):
                                 top = pbf_header_bbox.get_sint64();
                                 break;
-                            case OSMFormat::HeaderBBox::required_sint64_bottom:
+                            case protozero::tag_and_type(OSMFormat::HeaderBBox::required_sint64_bottom, protozero::pbf_wire_type::varint):
                                 bottom = pbf_header_bbox.get_sint64();
                                 break;
                             default:
@@ -805,11 +820,11 @@ namespace osmium {
 
                 protozero::pbf_message<OSMFormat::HeaderBlock> pbf_header_block{data};
                 while (pbf_header_block.next()) {
-                    switch (pbf_header_block.tag()) {
-                        case OSMFormat::HeaderBlock::optional_HeaderBBox_bbox:
+                    switch (pbf_header_block.tag_and_type()) {
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::optional_HeaderBBox_bbox, protozero::pbf_wire_type::length_delimited):
                             header.add_box(decode_header_bbox(pbf_header_block.get_view()));
                             break;
-                        case OSMFormat::HeaderBlock::repeated_string_required_features:
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::repeated_string_required_features, protozero::pbf_wire_type::length_delimited):
                             {
                                 auto feature = pbf_header_block.get_view();
                                 if (!std::strncmp("OsmSchema-V0.6", feature.data(), feature.size())) {
@@ -825,23 +840,23 @@ namespace osmium {
                                 }
                             }
                             break;
-                        case OSMFormat::HeaderBlock::repeated_string_optional_features:
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::repeated_string_optional_features, protozero::pbf_wire_type::length_delimited):
                             header.set("pbf_optional_feature_" + std::to_string(i++), pbf_header_block.get_string());
                             break;
-                        case OSMFormat::HeaderBlock::optional_string_writingprogram:
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::optional_string_writingprogram, protozero::pbf_wire_type::length_delimited):
                             header.set("generator", pbf_header_block.get_string());
                             break;
-                        case OSMFormat::HeaderBlock::optional_int64_osmosis_replication_timestamp:
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::optional_int64_osmosis_replication_timestamp, protozero::pbf_wire_type::varint):
                             {
                                 const auto timestamp = osmium::Timestamp{pbf_header_block.get_int64()}.to_iso();
                                 header.set("osmosis_replication_timestamp", timestamp);
                                 header.set("timestamp", timestamp);
                             }
                             break;
-                        case OSMFormat::HeaderBlock::optional_int64_osmosis_replication_sequence_number:
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::optional_int64_osmosis_replication_sequence_number, protozero::pbf_wire_type::varint):
                             header.set("osmosis_replication_sequence_number", std::to_string(pbf_header_block.get_int64()));
                             break;
-                        case OSMFormat::HeaderBlock::optional_string_osmosis_replication_base_url:
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::optional_string_osmosis_replication_base_url, protozero::pbf_wire_type::length_delimited):
                             header.set("osmosis_replication_base_url", pbf_header_block.get_string());
                             break;
                         default:
@@ -879,14 +894,6 @@ namespace osmium {
                     m_read_metadata(read_metadata) {
                 }
 
-                PBFDataBlobDecoder(const PBFDataBlobDecoder&) = default;
-                PBFDataBlobDecoder& operator=(const PBFDataBlobDecoder&) = default;
-
-                PBFDataBlobDecoder(PBFDataBlobDecoder&&) = default;
-                PBFDataBlobDecoder& operator=(PBFDataBlobDecoder&&) = default;
-
-                ~PBFDataBlobDecoder() noexcept = default;
-
                 osmium::memory::Buffer operator()() {
                     std::string output;
                     PBFPrimitiveBlockDecoder decoder{decode_blob(*m_input_buffer, output), m_read_types, m_read_metadata};
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp
index 1ab45957359..4edff20cc64 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,18 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include <protozero/pbf_message.hpp>
-#include <protozero/types.hpp>
-
 #include <osmium/io/detail/input_format.hpp>
 #include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
 #include <osmium/io/detail/pbf_decoder.hpp>
@@ -56,6 +44,18 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/thread/util.hpp>
 #include <osmium/util/config.hpp>
 
+#include <protozero/pbf_message.hpp>
+#include <protozero/types.hpp>
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
 namespace osmium {
 
     namespace io {
@@ -64,7 +64,7 @@ namespace osmium {
 
             class PBFParser : public Parser {
 
-                std::string m_input_buffer;
+                std::string m_input_buffer{};
 
                 /**
                  * Read the given number of bytes from the input queue.
@@ -105,7 +105,13 @@ namespace osmium {
                         return 0; // EOF
                     }
 
+                    #ifndef _WIN32
                     const uint32_t size = ntohl(size_in_network_byte_order);
+                    #else
+                    uint32_t size = size_in_network_byte_order;
+                    protozero::detail::byteswap_inplace(&size);
+                    #endif
+
                     if (size > static_cast<uint32_t>(max_blob_header_size)) {
                         throw osmium::pbf_error{"invalid BlobHeader size (> max_blob_header_size)"};
                     }
@@ -122,11 +128,11 @@ namespace osmium {
                     size_t blob_header_datasize = 0;
 
                     while (pbf_blob_header.next()) {
-                        switch (pbf_blob_header.tag()) {
-                            case FileFormat::BlobHeader::required_string_type:
+                        switch (pbf_blob_header.tag_and_type()) {
+                            case protozero::tag_and_type(FileFormat::BlobHeader::required_string_type, protozero::pbf_wire_type::length_delimited):
                                 blob_header_type = pbf_blob_header.get_view();
                                 break;
-                            case FileFormat::BlobHeader::required_int32_datasize:
+                            case protozero::tag_and_type(FileFormat::BlobHeader::required_int32_datasize, protozero::pbf_wire_type::varint):
                                 blob_header_datasize = pbf_blob_header.get_int32();
                                 break;
                             default:
@@ -138,7 +144,7 @@ namespace osmium {
                         throw osmium::pbf_error{"PBF format error: BlobHeader.datasize missing or zero."};
                     }
 
-                    if (std::strncmp(expected_type, blob_header_type.data(), blob_header_type.size())) {
+                    if (std::strncmp(expected_type, blob_header_type.data(), blob_header_type.size()) != 0) {
                         throw osmium::pbf_error{"blob does not have expected type (OSMHeader in first blob, OSMData in following blobs)"};
                     }
 
@@ -190,10 +196,15 @@ namespace osmium {
             public:
 
                 explicit PBFParser(parser_arguments& args) :
-                    Parser(args),
-                    m_input_buffer() {
+                    Parser(args) {
                 }
 
+                PBFParser(const PBFParser&) = delete;
+                PBFParser& operator=(const PBFParser&) = delete;
+
+                PBFParser(PBFParser&&) = delete;
+                PBFParser& operator=(PBFParser&&) = delete;
+
                 ~PBFParser() noexcept final = default;
 
                 void run() final {
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp
index 55cd0eaf6e9..777032b967f 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,19 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <cstdlib>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <protozero/pbf_builder.hpp>
-#include <protozero/pbf_writer.hpp>
-#include <protozero/types.hpp>
-
 #include <osmium/handler.hpp>
 #include <osmium/io/detail/output_format.hpp>
 #include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
@@ -61,6 +48,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/box.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
+#include <osmium/osm/metadata_options.hpp>
 #include <osmium/osm/node.hpp>
 #include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/object.hpp>
@@ -72,8 +60,22 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/thread/pool.hpp>
 #include <osmium/util/cast.hpp>
 #include <osmium/util/delta.hpp>
+#include <osmium/util/misc.hpp>
 #include <osmium/visitor.hpp>
 
+#include <protozero/pbf_builder.hpp>
+#include <protozero/pbf_writer.hpp>
+#include <protozero/types.hpp>
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 namespace osmium {
 
     namespace io {
@@ -82,8 +84,11 @@ namespace osmium {
 
             struct pbf_output_options {
 
+                /// Which metadata of objects should be added?
+                osmium::metadata_options add_metadata;
+
                 /// Should nodes be encoded in DenseNodes?
-                bool use_dense_nodes;
+                bool use_dense_nodes = true;
 
                 /**
                  * Should the PBF blobs contain zlib compressed data?
@@ -93,21 +98,18 @@ namespace osmium {
                  * the writing speed a little but the output will be 2x to 3x
                  * bigger.
                  */
-                bool use_compression;
-
-                /// Should metadata of objects be written?
-                bool add_metadata;
+                bool use_compression = true;
 
                 /// Add the "HistoricalInformation" header flag.
-                bool add_historical_information_flag;
+                bool add_historical_information_flag = false;
 
                 /// Should the visible flag be added to all OSM objects?
-                bool add_visible_flag;
+                bool add_visible_flag = false;
 
                 /// Should node locations be added to ways?
-                bool locations_on_ways;
+                bool locations_on_ways = false;
 
-            };
+            }; // struct pbf_output_options
 
             /**
              * Maximum number of items in a primitive block.
@@ -185,7 +187,12 @@ namespace osmium {
                     pbf_blob_header.add_string(FileFormat::BlobHeader::required_string_type, m_blob_type == pbf_blob_type::data ? "OSMData" : "OSMHeader");
                     pbf_blob_header.add_int32(FileFormat::BlobHeader::required_int32_datasize, static_cast_with_assert<int32_t>(blob_data.size()));
 
+#ifndef _WIN32
                     const uint32_t sz = htonl(static_cast_with_assert<uint32_t>(blob_header_data.size()));
+#else
+                    uint32_t sz = static_cast_with_assert<uint32_t>(blob_header_data.size());
+                    protozero::detail::byteswap_inplace(&sz);
+#endif
 
                     // write to output: the 4-byte BlobHeader-Size followed by the BlobHeader followed by the Blob
                     std::string output;
@@ -224,15 +231,15 @@ namespace osmium {
                 std::vector<int64_t> m_lons;
                 std::vector<int32_t> m_tags;
 
-                osmium::util::DeltaEncode<object_id_type, int64_t> m_delta_id;
+                osmium::DeltaEncode<object_id_type, int64_t> m_delta_id;
 
-                osmium::util::DeltaEncode<uint32_t, int64_t> m_delta_timestamp;
-                osmium::util::DeltaEncode<changeset_id_type, int64_t> m_delta_changeset;
-                osmium::util::DeltaEncode<user_id_type, int32_t> m_delta_uid;
-                osmium::util::DeltaEncode<uint32_t, int32_t> m_delta_user_sid;
+                osmium::DeltaEncode<uint32_t, int64_t> m_delta_timestamp;
+                osmium::DeltaEncode<changeset_id_type, int64_t> m_delta_changeset;
+                osmium::DeltaEncode<user_id_type, int32_t> m_delta_uid;
+                osmium::DeltaEncode<uint32_t, int32_t> m_delta_user_sid;
 
-                osmium::util::DeltaEncode<int64_t, int64_t> m_delta_lat;
-                osmium::util::DeltaEncode<int64_t, int64_t> m_delta_lon;
+                osmium::DeltaEncode<int64_t, int64_t> m_delta_lat;
+                osmium::DeltaEncode<int64_t, int64_t> m_delta_lon;
 
                 const pbf_output_options& m_options;
 
@@ -269,22 +276,30 @@ namespace osmium {
                     m_delta_lon.clear();
                 }
 
-                std::size_t size() const {
+                std::size_t size() const noexcept {
                     return m_ids.size() * 3 * sizeof(int64_t);
                 }
 
                 void add_node(const osmium::Node& node) {
                     m_ids.push_back(m_delta_id.update(node.id()));
 
-                    if (m_options.add_metadata) {
+                    if (m_options.add_metadata.version()) {
                         m_versions.push_back(static_cast_with_assert<int32_t>(node.version()));
+                    }
+                    if (m_options.add_metadata.timestamp()) {
                         m_timestamps.push_back(m_delta_timestamp.update(uint32_t(node.timestamp())));
+                    }
+                    if (m_options.add_metadata.changeset()) {
                         m_changesets.push_back(m_delta_changeset.update(node.changeset()));
+                    }
+                    if (m_options.add_metadata.uid()) {
                         m_uids.push_back(m_delta_uid.update(node.uid()));
+                    }
+                    if (m_options.add_metadata.user()) {
                         m_user_sids.push_back(m_delta_user_sid.update(m_stringtable.add(node.user())));
-                        if (m_options.add_visible_flag) {
-                            m_visibles.push_back(node.visible());
-                        }
+                    }
+                    if (m_options.add_visible_flag) {
+                        m_visibles.push_back(node.visible());
                     }
 
                     m_lats.push_back(m_delta_lat.update(lonlat2int(node.location().lat_without_check())));
@@ -303,14 +318,23 @@ namespace osmium {
 
                     pbf_dense_nodes.add_packed_sint64(OSMFormat::DenseNodes::packed_sint64_id, m_ids.cbegin(), m_ids.cend());
 
-                    if (m_options.add_metadata) {
+                    if (m_options.add_metadata.any() || m_options.add_visible_flag) {
                         protozero::pbf_builder<OSMFormat::DenseInfo> pbf_dense_info{pbf_dense_nodes, OSMFormat::DenseNodes::optional_DenseInfo_denseinfo};
-                        pbf_dense_info.add_packed_int32(OSMFormat::DenseInfo::packed_int32_version, m_versions.cbegin(), m_versions.cend());
-                        pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_timestamp, m_timestamps.cbegin(), m_timestamps.cend());
-                        pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_changeset, m_changesets.cbegin(), m_changesets.cend());
-                        pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_uid, m_uids.cbegin(), m_uids.cend());
-                        pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_user_sid, m_user_sids.cbegin(), m_user_sids.cend());
-
+                        if (m_options.add_metadata.version()) {
+                            pbf_dense_info.add_packed_int32(OSMFormat::DenseInfo::packed_int32_version, m_versions.cbegin(), m_versions.cend());
+                        }
+                        if (m_options.add_metadata.timestamp()) {
+                            pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_timestamp, m_timestamps.cbegin(), m_timestamps.cend());
+                        }
+                        if (m_options.add_metadata.changeset()) {
+                            pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_changeset, m_changesets.cbegin(), m_changesets.cend());
+                        }
+                        if (m_options.add_metadata.uid()) {
+                            pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_uid, m_uids.cbegin(), m_uids.cend());
+                        }
+                        if (m_options.add_metadata.user()) {
+                            pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_user_sid, m_user_sids.cbegin(), m_user_sids.cend());
+                        }
                         if (m_options.add_visible_flag) {
                             pbf_dense_info.add_packed_bool(OSMFormat::DenseInfo::packed_bool_visible, m_visibles.cbegin(), m_visibles.cend());
                         }
@@ -332,18 +356,14 @@ namespace osmium {
                 protozero::pbf_builder<OSMFormat::PrimitiveGroup> m_pbf_primitive_group;
                 StringTable m_stringtable;
                 DenseNodes m_dense_nodes;
-                OSMFormat::PrimitiveGroup m_type;
-                int m_count;
+                OSMFormat::PrimitiveGroup m_type = OSMFormat::PrimitiveGroup::unknown;
+                int m_count = 0;
 
             public:
 
                 explicit PrimitiveBlock(const pbf_output_options& options) :
-                    m_pbf_primitive_group_data(),
                     m_pbf_primitive_group(m_pbf_primitive_group_data),
-                    m_stringtable(),
-                    m_dense_nodes(m_stringtable, options),
-                    m_type(OSMFormat::PrimitiveGroup::unknown),
-                    m_count(0) {
+                    m_dense_nodes(m_stringtable, options) {
                 }
 
                 const std::string& group_data() {
@@ -367,7 +387,7 @@ namespace osmium {
                     }
                 }
 
-                protozero::pbf_builder<OSMFormat::PrimitiveGroup>& group() {
+                protozero::pbf_builder<OSMFormat::PrimitiveGroup>& group() noexcept {
                     ++m_count;
                     return m_pbf_primitive_group;
                 }
@@ -381,15 +401,15 @@ namespace osmium {
                     return m_stringtable.add(s);
                 }
 
-                int count() const {
+                int count() const noexcept {
                     return m_count;
                 }
 
-                OSMFormat::PrimitiveGroup type() const {
+                OSMFormat::PrimitiveGroup type() const noexcept {
                     return m_type;
                 }
 
-                std::size_t size() const {
+                std::size_t size() const noexcept {
                     return m_pbf_primitive_group_data.size() + m_stringtable.size() + m_dense_nodes.size();
                 }
 
@@ -401,7 +421,7 @@ namespace osmium {
                  */
                 constexpr static std::size_t max_used_blob_size = max_uncompressed_blob_size * 95 / 100;
 
-                bool can_add(OSMFormat::PrimitiveGroup type) const {
+                bool can_add(OSMFormat::PrimitiveGroup type) const noexcept {
                     if (type != m_type) {
                         return false;
                     }
@@ -457,14 +477,24 @@ namespace osmium {
                         }
                     }
 
-                    if (m_options.add_metadata) {
+                    if (m_options.add_metadata.any() || m_options.add_visible_flag) {
                         protozero::pbf_builder<OSMFormat::Info> pbf_info{pbf_object, T::enum_type::optional_Info_info};
 
-                        pbf_info.add_int32(OSMFormat::Info::optional_int32_version, static_cast_with_assert<int32_t>(object.version()));
-                        pbf_info.add_int64(OSMFormat::Info::optional_int64_timestamp, uint32_t(object.timestamp()));
-                        pbf_info.add_int64(OSMFormat::Info::optional_int64_changeset, object.changeset());
-                        pbf_info.add_int32(OSMFormat::Info::optional_int32_uid, static_cast_with_assert<int32_t>(object.uid()));
-                        pbf_info.add_uint32(OSMFormat::Info::optional_uint32_user_sid, m_primitive_block.store_in_stringtable(object.user()));
+                        if (m_options.add_metadata.version()) {
+                            pbf_info.add_int32(OSMFormat::Info::optional_int32_version, static_cast_with_assert<int32_t>(object.version()));
+                        }
+                        if (m_options.add_metadata.timestamp()) {
+                            pbf_info.add_int64(OSMFormat::Info::optional_int64_timestamp, uint32_t(object.timestamp()));
+                        }
+                        if (m_options.add_metadata.changeset()) {
+                            pbf_info.add_int64(OSMFormat::Info::optional_int64_changeset, object.changeset());
+                        }
+                        if (m_options.add_metadata.uid()) {
+                            pbf_info.add_int32(OSMFormat::Info::optional_int32_uid, static_cast_with_assert<int32_t>(object.uid()));
+                        }
+                        if (m_options.add_metadata.user()) {
+                            pbf_info.add_uint32(OSMFormat::Info::optional_uint32_user_sid, m_primitive_block.store_in_stringtable(object.user()));
+                        }
                         if (m_options.add_visible_flag) {
                             pbf_info.add_bool(OSMFormat::Info::optional_bool_visible, object.visible());
                         }
@@ -482,21 +512,20 @@ namespace osmium {
 
                 PBFOutputFormat(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) :
                     OutputFormat(pool, output_queue),
-                    m_options(),
                     m_primitive_block(m_options) {
+
+                    if (!file.get("pbf_add_metadata").empty()) {
+                        throw std::invalid_argument{"The 'pbf_add_metadata' option is deprecated. Please use 'add_metadata' instead."};
+                    }
+
                     m_options.use_dense_nodes = file.is_not_false("pbf_dense_nodes");
                     m_options.use_compression = file.get("pbf_compression") != "none" && file.is_not_false("pbf_compression");
-                    m_options.add_metadata = file.is_not_false("pbf_add_metadata") && file.is_not_false("add_metadata");
+                    m_options.add_metadata = osmium::metadata_options{file.get("add_metadata")};
                     m_options.add_historical_information_flag = file.has_multiple_object_versions();
                     m_options.add_visible_flag = file.has_multiple_object_versions();
                     m_options.locations_on_ways = file.is_true("locations_on_ways");
                 }
 
-                PBFOutputFormat(const PBFOutputFormat&) = delete;
-                PBFOutputFormat& operator=(const PBFOutputFormat&) = delete;
-
-                ~PBFOutputFormat() noexcept final = default;
-
                 void write_header(const osmium::io::Header& header) final {
                     std::string data;
                     protozero::pbf_builder<OSMFormat::HeaderBlock> pbf_header_block{data};
@@ -535,7 +564,7 @@ namespace osmium {
 
                     const std::string osmosis_replication_sequence_number{header.get("osmosis_replication_sequence_number")};
                     if (!osmosis_replication_sequence_number.empty()) {
-                        pbf_header_block.add_int64(OSMFormat::HeaderBlock::optional_int64_osmosis_replication_sequence_number, std::atoll(osmosis_replication_sequence_number.c_str()));
+                        pbf_header_block.add_int64(OSMFormat::HeaderBlock::optional_int64_osmosis_replication_sequence_number, osmium::detail::str_to_int<int64_t>(osmosis_replication_sequence_number.c_str()));
                     }
 
                     const std::string osmosis_replication_base_url{header.get("osmosis_replication_base_url")};
@@ -583,7 +612,7 @@ namespace osmium {
                     add_meta(way, pbf_way);
 
                     {
-                        osmium::util::DeltaEncode<object_id_type, int64_t> delta_id;
+                        osmium::DeltaEncode<object_id_type, int64_t> delta_id;
                         protozero::packed_field_sint64 field{pbf_way, protozero::pbf_tag_type(OSMFormat::Way::packed_sint64_refs)};
                         for (const auto& node_ref : way.nodes()) {
                             field.add_element(delta_id.update(node_ref.ref()));
@@ -592,14 +621,14 @@ namespace osmium {
 
                     if (m_options.locations_on_ways) {
                         {
-                            osmium::util::DeltaEncode<int64_t, int64_t> delta_id;
+                            osmium::DeltaEncode<int64_t, int64_t> delta_id;
                             protozero::packed_field_sint64 field{pbf_way, protozero::pbf_tag_type(OSMFormat::Way::packed_sint64_lon)};
                             for (const auto& node_ref : way.nodes()) {
                                 field.add_element(delta_id.update(lonlat2int(node_ref.location().lon_without_check())));
                             }
                         }
                         {
-                            osmium::util::DeltaEncode<int64_t, int64_t> delta_id;
+                            osmium::DeltaEncode<int64_t, int64_t> delta_id;
                             protozero::packed_field_sint64 field{pbf_way, protozero::pbf_tag_type(OSMFormat::Way::packed_sint64_lat)};
                             for (const auto& node_ref : way.nodes()) {
                                 field.add_element(delta_id.update(lonlat2int(node_ref.location().lat_without_check())));
@@ -623,7 +652,7 @@ namespace osmium {
                     }
 
                     {
-                        osmium::util::DeltaEncode<object_id_type, int64_t> delta_id;
+                        osmium::DeltaEncode<object_id_type, int64_t> delta_id;
                         protozero::packed_field_sint64 field{pbf_relation, protozero::pbf_tag_type(OSMFormat::Relation::packed_sint64_memids)};
                         for (const auto& member : relation.members()) {
                             field.add_element(delta_id.update(member.ref()));
diff --git a/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp b/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp
index 58fff569462..6b6dd93b79e 100644
--- a/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/detail/queue_util.hpp b/third_party/libosmium/include/osmium/io/detail/queue_util.hpp
index cb486ea8283..bee2c03d320 100644
--- a/third_party/libosmium/include/osmium/io/detail/queue_util.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/queue_util.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/buffer.hpp>
+#include <osmium/thread/queue.hpp>
+
 #include <cassert>
 #include <exception>
 #include <future>
 #include <string>
 #include <utility>
 
-#include <osmium/memory/buffer.hpp>
-#include <osmium/thread/queue.hpp>
-
 namespace osmium {
 
     namespace io {
@@ -110,6 +110,12 @@ namespace osmium {
                     m_has_reached_end_of_data(false) {
                 }
 
+                queue_wrapper(const queue_wrapper&) = delete;
+                queue_wrapper& operator=(const queue_wrapper&) = delete;
+
+                queue_wrapper(queue_wrapper&&) = delete;
+                queue_wrapper& operator=(queue_wrapper&&) = delete;
+
                 ~queue_wrapper() noexcept {
                     drain();
                 }
diff --git a/third_party/libosmium/include/osmium/io/detail/read_thread.hpp b/third_party/libosmium/include/osmium/io/detail/read_thread.hpp
index 007b37e9733..91f9cd93343 100644
--- a/third_party/libosmium/include/osmium/io/detail/read_thread.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/read_thread.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/io/compression.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/thread/util.hpp>
+
 #include <atomic>
 #include <exception>
 #include <string>
 #include <thread>
 #include <utility>
 
-#include <osmium/io/compression.hpp>
-#include <osmium/io/detail/queue_util.hpp>
-#include <osmium/thread/util.hpp>
-
 namespace osmium {
 
     namespace io {
diff --git a/third_party/libosmium/include/osmium/io/detail/read_write.hpp b/third_party/libosmium/include/osmium/io/detail/read_write.hpp
index 388d9713aa4..91ca2698330 100644
--- a/third_party/libosmium/include/osmium/io/detail/read_write.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/read_write.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/io/writer_options.hpp>
+
 #include <cerrno>
 #include <cstddef>
 #include <fcntl.h>
@@ -45,8 +47,6 @@ DEALINGS IN THE SOFTWARE.
 # include <io.h>
 #endif
 
-#include <osmium/io/writer_options.hpp>
-
 namespace osmium {
 
     namespace io {
@@ -67,14 +67,14 @@ namespace osmium {
              * @throws system_error if the file can't be opened.
              */
             inline int open_for_writing(const std::string& filename, osmium::io::overwrite allow_overwrite = osmium::io::overwrite::no) {
-                if (filename == "" || filename == "-") {
+                if (filename.empty() || filename == "-") {
 #ifdef _WIN32
                     _setmode(1, _O_BINARY);
 #endif
                     return 1; // stdout
                 }
 
-                int flags = O_WRONLY | O_CREAT;
+                int flags = O_WRONLY | O_CREAT; // NOLINT(hicpp-signed-bitwise)
                 if (allow_overwrite == osmium::io::overwrite::allow) {
                     flags |= O_TRUNC;
                 } else {
@@ -99,7 +99,7 @@ namespace osmium {
              * @throws system_error if the file can't be opened.
              */
             inline int open_for_reading(const std::string& filename) {
-                if (filename == "" || filename == "-") {
+                if (filename.empty() || filename == "-") {
                     return 0; // stdin
                 }
 
@@ -132,10 +132,14 @@ namespace osmium {
                     if (write_count > max_write) {
                         write_count = max_write;
                     }
-                    const auto length = ::write(fd, output_buffer + offset, static_cast<unsigned int>(write_count));
-                    if (length < 0) {
-                        throw std::system_error{errno, std::system_category(), "Write failed"};
-                    }
+
+                    int64_t length = 0;
+                    do {
+                        length = ::write(fd, output_buffer + offset, static_cast<unsigned int>(write_count));
+                        if (length < 0 && errno != EINTR) {
+                            throw std::system_error{errno, std::system_category(), "Write failed"};
+                        }
+                    } while (length < 0);
                     offset += static_cast<size_t>(length);
                 } while (offset < size);
             }
@@ -154,6 +158,30 @@ namespace osmium {
                 reliable_write(fd, reinterpret_cast<const unsigned char*>(output_buffer), size);
             }
 
+            /**
+             * Reads a maximum of size bytes from the file descriptor into the
+             * input_buffer. This is just a wrapper around read(2) catching
+             * errors.
+             *
+             * @param fd File descriptor.
+             * @param input_buffer Buffer for data to be read. Must be at least size bytes long.
+             * @param size Maximum number of bytes to read.
+             * @returns the number of bytes read
+             * @throws std::system_error On error.
+             */
+            inline int64_t reliable_read(const int fd, char* input_buffer, const unsigned int size) {
+                int64_t nread = 0;
+
+                do {
+                    nread = ::read(fd, input_buffer, size);
+                    if (nread < 0 && errno != EINTR) {
+                        throw std::system_error{errno, std::system_category(), "Read failed"};
+                    }
+                } while (nread < 0);
+
+                return nread;
+            }
+
             inline void reliable_fsync(const int fd) {
 #ifdef _WIN32
                 if (_commit(fd) != 0) {
diff --git a/third_party/libosmium/include/osmium/io/detail/string_table.hpp b/third_party/libosmium/include/osmium/io/detail/string_table.hpp
index 16172c54e9e..4d3fb1ff0ea 100644
--- a/third_party/libosmium/include/osmium/io/detail/string_table.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/string_table.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/io/detail/pbf.hpp>
+
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -43,8 +45,6 @@ DEALINGS IN THE SOFTWARE.
 #include <unordered_map>
 #include <utility>
 
-#include <osmium/io/detail/pbf.hpp>
-
 namespace osmium {
 
     namespace io {
@@ -77,8 +77,7 @@ namespace osmium {
             public:
 
                 explicit StringStore(size_t chunk_size) :
-                    m_chunk_size(chunk_size),
-                    m_chunks() {
+                    m_chunk_size(chunk_size) {
                     add_chunk();
                 }
 
@@ -212,12 +211,12 @@ namespace osmium {
 
             struct djb2_hash {
 
-                size_t operator()(const char* str) const noexcept {
-                    size_t hash = 5381;
+                std::size_t operator()(const char* str) const noexcept {
+                    std::size_t hash = 5381;
                     int c;
 
                     while ((c = *str++)) {
-                        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+                        hash = ((hash << 5u) + hash) + c; /* hash * 33 + c */
                     }
 
                     return hash;
@@ -245,14 +244,12 @@ namespace osmium {
 
                 StringStore m_strings;
                 std::unordered_map<const char*, size_t, djb2_hash, str_equal> m_index;
-                uint32_t m_size;
+                uint32_t m_size = 0;
 
             public:
 
                 explicit StringTable(size_t size = default_stringtable_chunk_size) :
-                    m_strings(size),
-                    m_index(),
-                    m_size(0) {
+                    m_strings(size) {
                     m_strings.add("");
                 }
 
diff --git a/third_party/libosmium/include/osmium/io/detail/string_util.hpp b/third_party/libosmium/include/osmium/io/detail/string_util.hpp
index b450b7b8608..c42761e6d1c 100644
--- a/third_party/libosmium/include/osmium/io/detail/string_util.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/string_util.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <utf8.h>
+
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
@@ -40,8 +42,6 @@ DEALINGS IN THE SOFTWARE.
 #include <string>
 #include <utility>
 
-#include <utf8.h>
-
 namespace osmium {
 
     namespace io {
@@ -127,22 +127,22 @@ namespace osmium {
 
             // Write out the value with exactly two hex digits.
             inline void append_2_hex_digits(std::string& out, uint32_t value, const char* const hex_digits) {
-                out += hex_digits[(value >> 4) & 0xf];
-                out += hex_digits[ value       & 0xf];
+                out += hex_digits[(value >> 4u) & 0xfu];
+                out += hex_digits[ value        & 0xfu];
             }
 
             // Write out the value with four or more hex digits.
             inline void append_min_4_hex_digits(std::string& out, uint32_t value, const char* const hex_digits) {
                 auto
-                v = value & 0xf0000000; if (v) { out += hex_digits[v >> 28]; }
-                v = value & 0x0f000000; if (v) { out += hex_digits[v >> 24]; }
-                v = value & 0x00f00000; if (v) { out += hex_digits[v >> 20]; }
-                v = value & 0x000f0000; if (v) { out += hex_digits[v >> 16]; }
-
-                out += hex_digits[(value >> 12) & 0xf];
-                out += hex_digits[(value >>  8) & 0xf];
-                out += hex_digits[(value >>  4) & 0xf];
-                out += hex_digits[ value        & 0xf];
+                v = value & 0xf0000000u; if (v) { out += hex_digits[v >> 28u]; }
+                v = value & 0x0f000000u; if (v) { out += hex_digits[v >> 24u]; }
+                v = value & 0x00f00000u; if (v) { out += hex_digits[v >> 20u]; }
+                v = value & 0x000f0000u; if (v) { out += hex_digits[v >> 16u]; }
+
+                out += hex_digits[(value >> 12u) & 0xfu];
+                out += hex_digits[(value >>  8u) & 0xfu];
+                out += hex_digits[(value >>  4u) & 0xfu];
+                out += hex_digits[ value         & 0xfu];
             }
 
             inline void append_utf8_encoded_string(std::string& out, const char* data) {
diff --git a/third_party/libosmium/include/osmium/io/detail/write_thread.hpp b/third_party/libosmium/include/osmium/io/detail/write_thread.hpp
index 575bc6b5c30..810543dc6c7 100644
--- a/third_party/libosmium/include/osmium/io/detail/write_thread.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/write_thread.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/io/compression.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/thread/util.hpp>
+
 #include <exception>
 #include <future>
 #include <memory>
 #include <string>
 #include <utility>
 
-#include <osmium/io/compression.hpp>
-#include <osmium/io/detail/queue_util.hpp>
-#include <osmium/thread/util.hpp>
-
 namespace osmium {
 
     namespace io {
diff --git a/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp
index 82c74ebfcf2..6007a9dae38 100644
--- a/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cstring>
-#include <future>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include <expat.h>
-
 #include <osmium/builder/builder.hpp>
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/io/detail/input_format.hpp>
@@ -64,7 +55,16 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types_from_string.hpp>
 #include <osmium/osm/way.hpp>
 #include <osmium/thread/util.hpp>
-#include <osmium/util/cast.hpp>
+
+#include <expat.h>
+
+#include <cassert>
+#include <cstring>
+#include <future>
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
 
 namespace osmium {
 
@@ -75,8 +75,8 @@ namespace osmium {
      */
     struct xml_error : public io_error {
 
-        unsigned long line;
-        unsigned long column;
+        uint64_t line = 0;
+        uint64_t column = 0;
         XML_Error error_code;
         std::string error_string;
 
@@ -95,8 +95,6 @@ namespace osmium {
 
         explicit xml_error(const std::string& message) :
             io_error(message),
-            line(0),
-            column(0),
             error_code(),
             error_string(message) {
         }
@@ -112,8 +110,7 @@ namespace osmium {
         std::string version;
 
         explicit format_version_error() :
-            io_error("Can not read file without version (missing version attribute on osm element)."),
-            version() {
+            io_error("Can not read file without version (missing version attribute on osm element).") {
         }
 
         explicit format_version_error(const char* v) :
@@ -129,54 +126,50 @@ namespace osmium {
 
             class XMLParser : public Parser {
 
-                static constexpr int buffer_size = 2 * 1000 * 1000;
+                static constexpr std::size_t buffer_size = 2 * 1000 * 1000;
 
                 enum class context {
-                    root,
-                    top,
+                    osm,
+                    osmChange,
+                    bounds,
+                    create_section,
+                    modify_section,
+                    delete_section,
                     node,
                     way,
                     relation,
+                    tag,
+                    nd,
+                    member,
                     changeset,
                     discussion,
                     comment,
-                    comment_text,
-                    ignored_node,
-                    ignored_way,
-                    ignored_relation,
-                    ignored_changeset,
-                    in_object
+                    text,
+                    other
                 }; // enum class context
 
-                context m_context;
-                context m_last_context;
+                std::vector<context> m_context_stack;
 
-                /**
-                 * This is used only for change files which contain create, modify,
-                 * and delete sections.
-                 */
-                bool m_in_delete_section;
-
-                osmium::io::Header m_header;
+                osmium::io::Header m_header{};
 
                 osmium::memory::Buffer m_buffer;
 
-                std::unique_ptr<osmium::builder::NodeBuilder>                m_node_builder;
-                std::unique_ptr<osmium::builder::WayBuilder>                 m_way_builder;
-                std::unique_ptr<osmium::builder::RelationBuilder>            m_relation_builder;
-                std::unique_ptr<osmium::builder::ChangesetBuilder>           m_changeset_builder;
-                std::unique_ptr<osmium::builder::ChangesetDiscussionBuilder> m_changeset_discussion_builder;
+                std::unique_ptr<osmium::builder::NodeBuilder>                m_node_builder{};
+                std::unique_ptr<osmium::builder::WayBuilder>                 m_way_builder{};
+                std::unique_ptr<osmium::builder::RelationBuilder>            m_relation_builder{};
+                std::unique_ptr<osmium::builder::ChangesetBuilder>           m_changeset_builder{};
+                std::unique_ptr<osmium::builder::ChangesetDiscussionBuilder> m_changeset_discussion_builder{};
 
-                std::unique_ptr<osmium::builder::TagListBuilder>             m_tl_builder;
-                std::unique_ptr<osmium::builder::WayNodeListBuilder>         m_wnl_builder;
-                std::unique_ptr<osmium::builder::RelationMemberListBuilder>  m_rml_builder;
+                std::unique_ptr<osmium::builder::TagListBuilder>             m_tl_builder{};
+                std::unique_ptr<osmium::builder::WayNodeListBuilder>         m_wnl_builder{};
+                std::unique_ptr<osmium::builder::RelationMemberListBuilder>  m_rml_builder{};
 
                 std::string m_comment_text;
 
                 /**
-                 * A C++ wrapper for the Expat parser that makes sure no memory is leaked.
+                 * A C++ wrapper for the Expat parser that makes sure no memory
+                 * is leaked.
                  */
-                template <typename T>
                 class ExpatXMLParser {
 
                     XML_Parser m_parser;
@@ -198,15 +191,21 @@ namespace osmium {
                     // but they can be misused. See
                     // https://en.wikipedia.org/wiki/Billion_laughs
                     // The handler will just throw an error.
-                    static void entity_declaration_handler(void*,
-                            const XML_Char*, int, const XML_Char*, int, const XML_Char*,
-                            const XML_Char*, const XML_Char*, const XML_Char*) {
+                    static void entity_declaration_handler(void* /*userData*/,
+                            const XML_Char* /*entityName*/,
+                            int /*is_parameter_entity*/,
+                            const XML_Char* /*value*/,
+                            int /*value_length*/,
+                            const XML_Char* /*base*/,
+                            const XML_Char* /*systemId*/,
+                            const XML_Char* /*publicId*/,
+                            const XML_Char* /*notationName*/) {
                         throw osmium::xml_error{"XML entities are not supported"};
                     }
 
                 public:
 
-                    explicit ExpatXMLParser(T* callback_object) :
+                    explicit ExpatXMLParser(void* callback_object) :
                         m_parser(XML_ParserCreate(nullptr)) {
                         if (!m_parser) {
                             throw osmium::io_error{"Internal error: Can not create parser"};
@@ -218,9 +217,9 @@ namespace osmium {
                     }
 
                     ExpatXMLParser(const ExpatXMLParser&) = delete;
-                    ExpatXMLParser(ExpatXMLParser&&) = delete;
-
                     ExpatXMLParser& operator=(const ExpatXMLParser&) = delete;
+
+                    ExpatXMLParser(ExpatXMLParser&&) = delete;
                     ExpatXMLParser& operator=(ExpatXMLParser&&) = delete;
 
                     ~ExpatXMLParser() noexcept {
@@ -228,7 +227,8 @@ namespace osmium {
                     }
 
                     void operator()(const std::string& data, bool last) {
-                        if (XML_Parse(m_parser, data.data(), static_cast_with_assert<int>(data.size()), last) == XML_STATUS_ERROR) {
+                        assert(data.size() < std::numeric_limits<int>::max());
+                        if (XML_Parse(m_parser, data.data(), static_cast<int>(data.size()), last) == XML_STATUS_ERROR) {
                             throw osmium::xml_error{m_parser};
                         }
                     }
@@ -236,21 +236,21 @@ namespace osmium {
                 }; // class ExpatXMLParser
 
                 template <typename T>
-                static void check_attributes(const XML_Char** attrs, T check) {
+                static void check_attributes(const XML_Char** attrs, T&& check) {
                     while (*attrs) {
-                        check(attrs[0], attrs[1]);
+                        std::forward<T>(check)(attrs[0], attrs[1]);
                         attrs += 2;
                     }
                 }
 
                 const char* init_object(osmium::OSMObject& object, const XML_Char** attrs) {
-                    const char* user = "";
-
-                    if (m_in_delete_section) {
+                    assert(m_context_stack.size() > 1);
+                    if (m_context_stack[m_context_stack.size() - 2] == context::delete_section) {
                         object.set_visible(false);
                     }
 
                     osmium::Location location;
+                    const char* user = "";
 
                     check_attributes(attrs, [&location, &user, &object](const XML_Char* name, const XML_Char* value) {
                         if (!std::strcmp(name, "lon")) {
@@ -298,9 +298,9 @@ namespace osmium {
                     const char* v = "";
 
                     check_attributes(attrs, [&k, &v](const XML_Char* name, const XML_Char* value) {
-                        if (name[0] == 'k' && name[1] == 0) {
+                        if (name[0] == 'k' && name[1] == '\0') {
                             k = value;
-                        } else if (name[0] == 'v' && name[1] == 0) {
+                        } else if (name[0] == 'v' && name[1] == '\0') {
                             v = value;
                         }
                     });
@@ -315,311 +315,390 @@ namespace osmium {
                     set_header_value(m_header);
                 }
 
-                void start_element(const XML_Char* element, const XML_Char** attrs) {
-                    switch (m_context) {
-                        case context::root:
-                            if (!std::strcmp(element, "osm") || !std::strcmp(element, "osmChange")) {
-                                if (!std::strcmp(element, "osmChange")) {
-                                    m_header.set_has_multiple_object_versions(true);
-                                }
-                                check_attributes(attrs, [this](const XML_Char* name, const XML_Char* value) {
-                                    if (!std::strcmp(name, "version")) {
-                                        m_header.set("version", value);
-                                        if (std::strcmp(value, "0.6")) {
-                                            throw osmium::format_version_error{value};
-                                        }
-                                    } else if (!std::strcmp(name, "generator")) {
-                                        m_header.set("generator", value);
-                                    }
-                                });
-                                if (m_header.get("version") == "") {
-                                    throw osmium::format_version_error{};
-                                }
-                            } else {
-                                throw osmium::xml_error{std::string{"Unknown top-level element: "} + element};
+                void top_level_element(const XML_Char* element, const XML_Char** attrs) {
+                    if (!std::strcmp(element, "osm")) {
+                        m_context_stack.push_back(context::osm);
+                    } else if (!std::strcmp(element, "osmChange")){
+                        m_context_stack.push_back(context::osmChange);
+                        m_header.set_has_multiple_object_versions(true);
+                    } else {
+                        throw osmium::xml_error{std::string{"Unknown top-level element: "} + element};
+                    }
+
+                    check_attributes(attrs, [this](const XML_Char* name, const XML_Char* value) {
+                        if (!std::strcmp(name, "version")) {
+                            m_header.set("version", value);
+                            if (std::strcmp(value, "0.6") != 0) {
+                                throw osmium::format_version_error{value};
                             }
-                            m_context = context::top;
-                            break;
-                        case context::top:
-                            assert(!m_tl_builder);
-                            if (!std::strcmp(element, "node")) {
-                                mark_header_as_done();
-                                if (read_types() & osmium::osm_entity_bits::node) {
-                                    m_node_builder.reset(new osmium::builder::NodeBuilder{m_buffer});
-                                    m_node_builder->set_user(init_object(m_node_builder->object(), attrs));
-                                    m_context = context::node;
-                                } else {
-                                    m_context = context::ignored_node;
-                                }
-                            } else if (!std::strcmp(element, "way")) {
-                                mark_header_as_done();
-                                if (read_types() & osmium::osm_entity_bits::way) {
-                                    m_way_builder.reset(new osmium::builder::WayBuilder{m_buffer});
-                                    m_way_builder->set_user(init_object(m_way_builder->object(), attrs));
-                                    m_context = context::way;
-                                } else {
-                                    m_context = context::ignored_way;
-                                }
-                            } else if (!std::strcmp(element, "relation")) {
-                                mark_header_as_done();
-                                if (read_types() & osmium::osm_entity_bits::relation) {
-                                    m_relation_builder.reset(new osmium::builder::RelationBuilder{m_buffer});
-                                    m_relation_builder->set_user(init_object(m_relation_builder->object(), attrs));
-                                    m_context = context::relation;
-                                } else {
-                                    m_context = context::ignored_relation;
-                                }
-                            } else if (!std::strcmp(element, "changeset")) {
-                                mark_header_as_done();
-                                if (read_types() & osmium::osm_entity_bits::changeset) {
-                                    m_changeset_builder.reset(new osmium::builder::ChangesetBuilder{m_buffer});
-                                    init_changeset(*m_changeset_builder, attrs);
-                                    m_context = context::changeset;
-                                } else {
-                                    m_context = context::ignored_changeset;
-                                }
-                            } else if (!std::strcmp(element, "bounds")) {
-                                osmium::Location min;
-                                osmium::Location max;
-                                check_attributes(attrs, [&min, &max](const XML_Char* name, const XML_Char* value) {
-                                    if (!std::strcmp(name, "minlon")) {
-                                        min.set_lon(value);
-                                    } else if (!std::strcmp(name, "minlat")) {
-                                        min.set_lat(value);
-                                    } else if (!std::strcmp(name, "maxlon")) {
-                                        max.set_lon(value);
-                                    } else if (!std::strcmp(name, "maxlat")) {
-                                        max.set_lat(value);
-                                    }
-                                });
-                                osmium::Box box;
-                                box.extend(min).extend(max);
-                                m_header.add_box(box);
-                            } else if (!std::strcmp(element, "delete")) {
-                                m_in_delete_section = true;
+                        } else if (!std::strcmp(name, "generator")) {
+                            m_header.set("generator", value);
+                        }
+                        // ignore other attributes
+                    });
+
+                    if (m_header.get("version").empty()) {
+                        throw osmium::format_version_error{};
+                    }
+                }
+
+                void data_level_element(const XML_Char* element, const XML_Char** attrs, bool in_change_section) {
+                    assert(!m_node_builder);
+                    assert(!m_way_builder);
+                    assert(!m_relation_builder);
+                    assert(!m_changeset_builder);
+                    assert(!m_changeset_discussion_builder);
+                    assert(!m_tl_builder);
+                    assert(!m_wnl_builder);
+                    assert(!m_rml_builder);
+
+                    if (!std::strcmp(element, "node")) {
+                        m_context_stack.push_back(context::node);
+                        mark_header_as_done();
+                        if (read_types() & osmium::osm_entity_bits::node) {
+                            m_node_builder.reset(new osmium::builder::NodeBuilder{m_buffer});
+                            m_node_builder->set_user(init_object(m_node_builder->object(), attrs));
+                        }
+                        return;
+                    }
+
+                    if (!std::strcmp(element, "way")) {
+                        m_context_stack.push_back(context::way);
+                        mark_header_as_done();
+                        if (read_types() & osmium::osm_entity_bits::way) {
+                            m_way_builder.reset(new osmium::builder::WayBuilder{m_buffer});
+                            m_way_builder->set_user(init_object(m_way_builder->object(), attrs));
+                        }
+                        return;
+                    }
+
+                    if (!std::strcmp(element, "relation")) {
+                        m_context_stack.push_back(context::relation);
+                        mark_header_as_done();
+                        if (read_types() & osmium::osm_entity_bits::relation) {
+                            m_relation_builder.reset(new osmium::builder::RelationBuilder{m_buffer});
+                            m_relation_builder->set_user(init_object(m_relation_builder->object(), attrs));
+                        }
+                        return;
+                    }
+
+                    if (in_change_section) {
+                        throw xml_error{"create/modify/delete sections can only contain nodes, ways, and relations"};
+                    }
+
+                    if (!std::strcmp(element, "changeset")) {
+                        m_context_stack.push_back(context::changeset);
+                        mark_header_as_done();
+                        if (read_types() & osmium::osm_entity_bits::changeset) {
+                            m_changeset_builder.reset(new osmium::builder::ChangesetBuilder{m_buffer});
+                            init_changeset(*m_changeset_builder, attrs);
+                        }
+                    } else if (!std::strcmp(element, "create")) {
+                        if (m_context_stack.back() != context::osmChange) {
+                            throw xml_error{"<create> only allowed in OSM change files"};
+                        }
+                        m_context_stack.push_back(context::create_section);
+                        mark_header_as_done();
+                    } else if (!std::strcmp(element, "modify")) {
+                        if (m_context_stack.back() != context::osmChange) {
+                            throw xml_error{"<modify> only allowed in OSM change files"};
+                        }
+                        m_context_stack.push_back(context::modify_section);
+                        mark_header_as_done();
+                    } else if (!std::strcmp(element, "delete")) {
+                        if (m_context_stack.back() != context::osmChange) {
+                            throw xml_error{"<delete> only allowed in OSM change files"};
+                        }
+                        m_context_stack.push_back(context::delete_section);
+                        mark_header_as_done();
+                    } else if (!std::strcmp(element, "bounds")) {
+                        m_context_stack.push_back(context::bounds);
+                        osmium::Location min;
+                        osmium::Location max;
+                        check_attributes(attrs, [&min, &max](const XML_Char* name, const XML_Char* value) {
+                            if (!std::strcmp(name, "minlon")) {
+                                min.set_lon(value);
+                            } else if (!std::strcmp(name, "minlat")) {
+                                min.set_lat(value);
+                            } else if (!std::strcmp(name, "maxlon")) {
+                                max.set_lon(value);
+                            } else if (!std::strcmp(name, "maxlat")) {
+                                max.set_lat(value);
                             }
+                        });
+                        osmium::Box box;
+                        box.extend(min).extend(max);
+                        m_header.add_box(box);
+                    } else {
+                        m_context_stack.push_back(context::other);
+                    }
+                }
+
+                void start_element(const XML_Char* element, const XML_Char** attrs) {
+                    if (m_context_stack.empty()) {
+                        top_level_element(element, attrs);
+                        return;
+                    }
+
+                    switch (m_context_stack.back()) {
+                        case context::osm:
+                            // fallthrough
+                        case context::osmChange:
+                            data_level_element(element, attrs, false);
+                            break;
+                        case context::create_section:
+                            // fallthrough
+                        case context::modify_section:
+                            // fallthrough
+                        case context::delete_section:
+                            data_level_element(element, attrs, true);
                             break;
                         case context::node:
-                            m_last_context = context::node;
-                            m_context = context::in_object;
                             if (!std::strcmp(element, "tag")) {
-                                get_tag(*m_node_builder, attrs);
+                                m_context_stack.push_back(context::tag);
+                                if (read_types() & osmium::osm_entity_bits::node) {
+                                    get_tag(*m_node_builder, attrs);
+                                }
+                            } else {
+                                throw xml_error{std::string{"Unknown element in <node>: "} + element};
                             }
                             break;
                         case context::way:
-                            m_last_context = context::way;
-                            m_context = context::in_object;
                             if (!std::strcmp(element, "nd")) {
-                                m_tl_builder.reset();
-
-                                if (!m_wnl_builder) {
-                                    m_wnl_builder.reset(new osmium::builder::WayNodeListBuilder{*m_way_builder});
-                                }
+                                m_context_stack.push_back(context::nd);
+                                if (read_types() & osmium::osm_entity_bits::way) {
+                                    m_tl_builder.reset();
 
-                                NodeRef nr;
-                                check_attributes(attrs, [this, &nr](const XML_Char* name, const XML_Char* value) {
-                                    if (!std::strcmp(name, "ref")) {
-                                        nr.set_ref(osmium::string_to_object_id(value));
-                                    } else if (!std::strcmp(name, "lon")) {
-                                        nr.location().set_lon(value);
-                                    } else if (!std::strcmp(name, "lat")) {
-                                        nr.location().set_lat(value);
+                                    if (!m_wnl_builder) {
+                                        m_wnl_builder.reset(new osmium::builder::WayNodeListBuilder{*m_way_builder});
                                     }
-                                });
-                                m_wnl_builder->add_node_ref(nr);
+
+                                    NodeRef nr;
+                                    check_attributes(attrs, [&nr](const XML_Char* name, const XML_Char* value) {
+                                        if (!std::strcmp(name, "ref")) {
+                                            nr.set_ref(osmium::string_to_object_id(value));
+                                        } else if (!std::strcmp(name, "lon")) {
+                                            nr.location().set_lon(value);
+                                        } else if (!std::strcmp(name, "lat")) {
+                                            nr.location().set_lat(value);
+                                        }
+                                    });
+                                    m_wnl_builder->add_node_ref(nr);
+                                }
                             } else if (!std::strcmp(element, "tag")) {
-                                m_wnl_builder.reset();
-                                get_tag(*m_way_builder, attrs);
+                                m_context_stack.push_back(context::tag);
+                                if (read_types() & osmium::osm_entity_bits::way) {
+                                    m_wnl_builder.reset();
+                                    get_tag(*m_way_builder, attrs);
+                                }
+                            } else {
+                                throw xml_error{std::string{"Unknown element in <way>: "} + element};
                             }
                             break;
                         case context::relation:
-                            m_last_context = context::relation;
-                            m_context = context::in_object;
                             if (!std::strcmp(element, "member")) {
-                                m_tl_builder.reset();
+                                m_context_stack.push_back(context::member);
+                                if (read_types() & osmium::osm_entity_bits::relation) {
+                                    m_tl_builder.reset();
 
-                                if (!m_rml_builder) {
-                                    m_rml_builder.reset(new osmium::builder::RelationMemberListBuilder{*m_relation_builder});
-                                }
+                                    if (!m_rml_builder) {
+                                        m_rml_builder.reset(new osmium::builder::RelationMemberListBuilder{*m_relation_builder});
+                                    }
 
-                                item_type type = item_type::undefined;
-                                object_id_type ref = 0;
-                                bool ref_is_set = false;
-                                const char* role = "";
-                                check_attributes(attrs, [&](const XML_Char* name, const XML_Char* value) {
-                                    if (!std::strcmp(name, "type")) {
-                                        type = char_to_item_type(value[0]);
-                                    } else if (!std::strcmp(name, "ref")) {
-                                        ref = osmium::string_to_object_id(value);
-                                        ref_is_set = true;
-                                    } else if (!std::strcmp(name, "role")) {
-                                        role = static_cast<const char*>(value);
+                                    item_type type = item_type::undefined;
+                                    object_id_type ref = 0;
+                                    bool ref_is_set = false;
+                                    const char* role = "";
+                                    check_attributes(attrs, [&type, &ref, &ref_is_set, &role](const XML_Char* name, const XML_Char* value) {
+                                        if (!std::strcmp(name, "type")) {
+                                            type = char_to_item_type(value[0]);
+                                        } else if (!std::strcmp(name, "ref")) {
+                                            ref = osmium::string_to_object_id(value);
+                                            ref_is_set = true;
+                                        } else if (!std::strcmp(name, "role")) {
+                                            role = static_cast<const char*>(value);
+                                        }
+                                    });
+                                    if (type != item_type::node && type != item_type::way && type != item_type::relation) {
+                                        throw osmium::xml_error{"Unknown type on relation <member>"};
                                     }
-                                });
-                                if (type != item_type::node && type != item_type::way && type != item_type::relation) {
-                                    throw osmium::xml_error{"Unknown type on relation member"};
-                                }
-                                if (!ref_is_set) {
-                                    throw osmium::xml_error{"Missing ref on relation member"};
+                                    if (!ref_is_set) {
+                                        throw osmium::xml_error{"Missing ref on relation <member>"};
+                                    }
+                                    m_rml_builder->add_member(type, ref, role);
                                 }
-                                m_rml_builder->add_member(type, ref, role);
                             } else if (!std::strcmp(element, "tag")) {
-                                m_rml_builder.reset();
-                                get_tag(*m_relation_builder, attrs);
+                                m_context_stack.push_back(context::tag);
+                                if (read_types() & osmium::osm_entity_bits::relation) {
+                                    m_rml_builder.reset();
+                                    get_tag(*m_relation_builder, attrs);
+                                }
+                            } else {
+                                throw xml_error{std::string{"Unknown element in <relation>: "} + element};
                             }
                             break;
+                        case context::tag:
+                            throw xml_error{"No element inside <tag> allowed"};
+                        case context::nd:
+                            throw xml_error{"No element inside <nd> allowed"};
+                        case context::member:
+                            throw xml_error{"No element inside <member> allowed"};
                         case context::changeset:
-                            m_last_context = context::changeset;
                             if (!std::strcmp(element, "discussion")) {
-                                m_context = context::discussion;
-                                m_tl_builder.reset();
-                                if (!m_changeset_discussion_builder) {
-                                    m_changeset_discussion_builder.reset(new osmium::builder::ChangesetDiscussionBuilder{*m_changeset_builder});
+                                m_context_stack.push_back(context::discussion);
+                                if (read_types() & osmium::osm_entity_bits::changeset) {
+                                    m_tl_builder.reset();
+                                    if (!m_changeset_discussion_builder) {
+                                        m_changeset_discussion_builder.reset(new osmium::builder::ChangesetDiscussionBuilder{*m_changeset_builder});
+                                    }
                                 }
                             } else if (!std::strcmp(element, "tag")) {
-                                m_context = context::in_object;
-                                m_changeset_discussion_builder.reset();
-                                get_tag(*m_changeset_builder, attrs);
+                                m_context_stack.push_back(context::tag);
+                                if (read_types() & osmium::osm_entity_bits::changeset) {
+                                    m_changeset_discussion_builder.reset();
+                                    get_tag(*m_changeset_builder, attrs);
+                                }
+                            } else {
+                                throw xml_error{std::string{"Unknown element in <changeset>: "} + element};
                             }
                             break;
                         case context::discussion:
                             if (!std::strcmp(element, "comment")) {
-                                m_context = context::comment;
-                                osmium::Timestamp date;
-                                osmium::user_id_type uid = 0;
-                                const char* user = "";
-                                check_attributes(attrs, [&date, &uid, &user](const XML_Char* name, const XML_Char* value) {
-                                    if (!std::strcmp(name, "date")) {
-                                        date = osmium::Timestamp(value);
-                                    } else if (!std::strcmp(name, "uid")) {
-                                        uid = osmium::string_to_user_id(value);
-                                    } else if (!std::strcmp(name, "user")) {
-                                        user = static_cast<const char*>(value);
-                                    }
-                                });
-                                m_changeset_discussion_builder->add_comment(date, uid, user);
+                                m_context_stack.push_back(context::comment);
+                                if (read_types() & osmium::osm_entity_bits::changeset) {
+                                    osmium::Timestamp date;
+                                    osmium::user_id_type uid = 0;
+                                    const char* user = "";
+                                    check_attributes(attrs, [&date, &uid, &user](const XML_Char* name, const XML_Char* value) {
+                                        if (!std::strcmp(name, "date")) {
+                                            date = osmium::Timestamp{value};
+                                        } else if (!std::strcmp(name, "uid")) {
+                                            uid = osmium::string_to_uid(value);
+                                        } else if (!std::strcmp(name, "user")) {
+                                            user = static_cast<const char*>(value);
+                                        }
+                                    });
+                                    m_changeset_discussion_builder->add_comment(date, uid, user);
+                                }
+                            } else {
+                                throw xml_error{std::string{"Unknown element in <discussion>: "} + element};
                             }
                             break;
                         case context::comment:
                             if (!std::strcmp(element, "text")) {
-                                m_context = context::comment_text;
+                                m_context_stack.push_back(context::text);
+                            } else {
+                                throw xml_error{std::string{"Unknown element in <comment>: "} + element};
                             }
                             break;
-                        case context::comment_text:
-                            break;
-                        case context::ignored_node:
-                            break;
-                        case context::ignored_way:
-                            break;
-                        case context::ignored_relation:
-                            break;
-                        case context::ignored_changeset:
-                            break;
-                        case context::in_object:
-                            assert(false); // should never be here
-                            break;
+                        case context::text:
+                            throw osmium::xml_error{"No element in <text> allowed"};
+                        case context::bounds:
+                            throw osmium::xml_error{"No element in <bounds> allowed"};
+                        case context::other:
+                            throw xml_error{"xml file nested too deep"};
                     }
                 }
 
                 void end_element(const XML_Char* element) {
-                    switch (m_context) {
-                        case context::root:
-                            assert(false); // should never be here
+                    assert(!m_context_stack.empty());
+                    switch (m_context_stack.back()) {
+                        case context::osm:
+                            assert(!std::strcmp(element, "osm"));
+                            mark_header_as_done();
                             break;
-                        case context::top:
-                            if (!std::strcmp(element, "osm") || !std::strcmp(element, "osmChange")) {
-                                mark_header_as_done();
-                                m_context = context::root;
-                            } else if (!std::strcmp(element, "delete")) {
-                                m_in_delete_section = false;
-                            }
+                        case context::osmChange:
+                            assert(!std::strcmp(element, "osmChange"));
+                            mark_header_as_done();
+                            break;
+                        case context::create_section:
+                            assert(!std::strcmp(element, "create"));
+                            break;
+                        case context::modify_section:
+                            assert(!std::strcmp(element, "modify"));
+                            break;
+                        case context::delete_section:
+                            assert(!std::strcmp(element, "delete"));
                             break;
                         case context::node:
                             assert(!std::strcmp(element, "node"));
-                            m_tl_builder.reset();
-                            m_node_builder.reset();
-                            m_buffer.commit();
-                            m_context = context::top;
-                            flush_buffer();
+                            if (read_types() & osmium::osm_entity_bits::node) {
+                                m_tl_builder.reset();
+                                m_node_builder.reset();
+                                m_buffer.commit();
+                                flush_buffer();
+                            }
                             break;
                         case context::way:
                             assert(!std::strcmp(element, "way"));
-                            m_tl_builder.reset();
-                            m_wnl_builder.reset();
-                            m_way_builder.reset();
-                            m_buffer.commit();
-                            m_context = context::top;
-                            flush_buffer();
+                            if (read_types() & osmium::osm_entity_bits::way) {
+                                m_tl_builder.reset();
+                                m_wnl_builder.reset();
+                                m_way_builder.reset();
+                                m_buffer.commit();
+                                flush_buffer();
+                            }
                             break;
                         case context::relation:
                             assert(!std::strcmp(element, "relation"));
-                            m_tl_builder.reset();
-                            m_rml_builder.reset();
-                            m_relation_builder.reset();
-                            m_buffer.commit();
-                            m_context = context::top;
-                            flush_buffer();
+                            if (read_types() & osmium::osm_entity_bits::relation) {
+                                m_tl_builder.reset();
+                                m_rml_builder.reset();
+                                m_relation_builder.reset();
+                                m_buffer.commit();
+                                flush_buffer();
+                            }
+                            break;
+                        case context::tag:
+                            break;
+                        case context::nd:
+                            break;
+                        case context::member:
                             break;
                         case context::changeset:
                             assert(!std::strcmp(element, "changeset"));
-                            m_tl_builder.reset();
-                            m_changeset_discussion_builder.reset();
-                            m_changeset_builder.reset();
-                            m_buffer.commit();
-                            m_context = context::top;
-                            flush_buffer();
+                            if (read_types() & osmium::osm_entity_bits::changeset) {
+                                m_tl_builder.reset();
+                                m_changeset_discussion_builder.reset();
+                                m_changeset_builder.reset();
+                                m_buffer.commit();
+                                flush_buffer();
+                            }
                             break;
                         case context::discussion:
                             assert(!std::strcmp(element, "discussion"));
-                            m_context = context::changeset;
                             break;
                         case context::comment:
                             assert(!std::strcmp(element, "comment"));
-                            m_context = context::discussion;
                             break;
-                        case context::comment_text:
+                        case context::text:
                             assert(!std::strcmp(element, "text"));
-                            m_context = context::comment;
-                            m_changeset_discussion_builder->add_comment_text(m_comment_text);
-                            break;
-                        case context::in_object:
-                            m_context = m_last_context;
-                            break;
-                        case context::ignored_node:
-                            if (!std::strcmp(element, "node")) {
-                                m_context = context::top;
+                            if (read_types() & osmium::osm_entity_bits::changeset) {
+                                m_changeset_discussion_builder->add_comment_text(m_comment_text);
+                                m_comment_text.clear();
                             }
                             break;
-                        case context::ignored_way:
-                            if (!std::strcmp(element, "way")) {
-                                m_context = context::top;
-                            }
+                        case context::bounds:
+                            assert(!std::strcmp(element, "bounds"));
                             break;
-                        case context::ignored_relation:
-                            if (!std::strcmp(element, "relation")) {
-                                m_context = context::top;
-                            }
-                            break;
-                        case context::ignored_changeset:
-                            if (!std::strcmp(element, "changeset")) {
-                                m_context = context::top;
-                            }
+                        case context::other:
                             break;
                     }
+                    m_context_stack.pop_back();
                 }
 
                 void characters(const XML_Char* text, int len) {
-                    if (m_context == context::comment_text) {
+                    if ((read_types() & osmium::osm_entity_bits::changeset) &&
+                        !m_context_stack.empty() &&
+                        m_context_stack.back() == context::text) {
                         m_comment_text.append(text, len);
-                    } else {
-                        m_comment_text.resize(0);
                     }
                 }
 
                 void flush_buffer() {
                     if (m_buffer.committed() > buffer_size / 10 * 9) {
                         send_to_output_queue(std::move(m_buffer));
-                        osmium::memory::Buffer buffer(buffer_size);
+                        osmium::memory::Buffer buffer{buffer_size};
                         using std::swap;
                         swap(m_buffer, buffer);
                     }
@@ -629,27 +708,21 @@ namespace osmium {
 
                 explicit XMLParser(parser_arguments& args) :
                     Parser(args),
-                    m_context(context::root),
-                    m_last_context(context::root),
-                    m_in_delete_section(false),
-                    m_header(),
-                    m_buffer(buffer_size),
-                    m_node_builder(),
-                    m_way_builder(),
-                    m_relation_builder(),
-                    m_changeset_builder(),
-                    m_changeset_discussion_builder(),
-                    m_tl_builder(),
-                    m_wnl_builder(),
-                    m_rml_builder() {
+                    m_buffer(buffer_size) {
                 }
 
+                XMLParser(const XMLParser&) = delete;
+                XMLParser& operator=(const XMLParser&) = delete;
+
+                XMLParser(XMLParser&&) = delete;
+                XMLParser& operator=(XMLParser&&) = delete;
+
                 ~XMLParser() noexcept final = default;
 
                 void run() final {
                     osmium::thread::set_thread_name("_osmium_xml_in");
 
-                    ExpatXMLParser<XMLParser> parser(this);
+                    ExpatXMLParser parser{this};
 
                     while (!input_done()) {
                         const std::string data{get_input()};
diff --git a/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp
index a8898740518..fa0c9edf1af 100644
--- a/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <iterator>
-#include <memory>
-#include <string>
-#include <utility>
-
 #include <osmium/handler.hpp>
 #include <osmium/io/detail/output_format.hpp>
 #include <osmium/io/detail/queue_util.hpp>
@@ -51,6 +46,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/changeset.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
+#include <osmium/osm/metadata_options.hpp>
 #include <osmium/osm/node.hpp>
 #include <osmium/osm/node_ref.hpp>
 #include <osmium/osm/object.hpp>
@@ -62,6 +58,11 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/thread/pool.hpp>
 #include <osmium/visitor.hpp>
 
+#include <iterator>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace io {
@@ -72,21 +73,22 @@ namespace osmium {
 
             struct xml_output_options {
 
-                /// Should metadata of objects be added?
-                bool add_metadata;
+                /// Which metadata of objects should be added?
+                osmium::metadata_options add_metadata;
 
                 /// Should the visible flag be added to all OSM objects?
-                bool add_visible_flag;
+                bool add_visible_flag = false;
 
                 /**
                  * Should <create>, <modify>, <delete> "operations" be added?
                  * (This is used for .osc files.)
                  */
-                bool use_change_ops;
+                bool use_change_ops = false;
 
                 /// Should node locations be added to ways?
-                bool locations_on_ways;
-            };
+                bool locations_on_ways = false;
+
+            }; // struct xml_output_options
 
             namespace detail {
 
@@ -144,34 +146,35 @@ namespace osmium {
                 void write_meta(const osmium::OSMObject& object) {
                     write_attribute("id", object.id());
 
-                    if (m_options.add_metadata) {
-                        if (object.version()) {
-                            write_attribute("version", object.version());
-                        }
+                    if (m_options.add_metadata.version() && object.version()) {
+                        write_attribute("version", object.version());
+                    }
 
-                        if (object.timestamp()) {
-                            *m_out += " timestamp=\"";
-                            *m_out += object.timestamp().to_iso();
-                            *m_out += "\"";
-                        }
+                    if (m_options.add_metadata.timestamp() && object.timestamp()) {
+                        *m_out += " timestamp=\"";
+                        *m_out += object.timestamp().to_iso();
+                        *m_out += "\"";
+                    }
 
-                        if (!object.user_is_anonymous()) {
-                            write_attribute("uid", object.uid());
-                            *m_out += " user=\"";
-                            append_xml_encoded_string(*m_out, object.user());
-                            *m_out += "\"";
-                        }
+                    if (m_options.add_metadata.uid() && object.uid()) {
+                        write_attribute("uid", object.uid());
+                    }
 
-                        if (object.changeset()) {
-                            write_attribute("changeset", object.changeset());
-                        }
+                    if (m_options.add_metadata.user() && object.user()[0] != '\0') {
+                        *m_out += " user=\"";
+                        append_xml_encoded_string(*m_out, object.user());
+                        *m_out += "\"";
+                    }
 
-                        if (m_options.add_visible_flag) {
-                            if (object.visible()) {
-                                *m_out += " visible=\"true\"";
-                            } else {
-                                *m_out += " visible=\"false\"";
-                            }
+                    if (m_options.add_metadata.changeset() && object.changeset()) {
+                        write_attribute("changeset", object.changeset());
+                    }
+
+                    if (m_options.add_visible_flag) {
+                        if (object.visible()) {
+                            *m_out += " visible=\"true\"";
+                        } else {
+                            *m_out += " visible=\"false\"";
                         }
                     }
                 }
@@ -247,14 +250,6 @@ namespace osmium {
                     m_options(options) {
                 }
 
-                XMLOutputBlock(const XMLOutputBlock&) = default;
-                XMLOutputBlock& operator=(const XMLOutputBlock&) = default;
-
-                XMLOutputBlock(XMLOutputBlock&&) = default;
-                XMLOutputBlock& operator=(XMLOutputBlock&&) = default;
-
-                ~XMLOutputBlock() noexcept = default;
-
                 std::string operator()() {
                     osmium::apply(m_input_buffer->cbegin(), m_input_buffer->cend(), *this);
 
@@ -432,19 +427,13 @@ namespace osmium {
             public:
 
                 XMLOutputFormat(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) :
-                    OutputFormat(pool, output_queue),
-                    m_options() {
-                    m_options.add_metadata      = file.is_not_false("add_metadata");
+                    OutputFormat(pool, output_queue) {
+                    m_options.add_metadata      = osmium::metadata_options{file.get("add_metadata")};
                     m_options.use_change_ops    = file.is_true("xml_change_format");
                     m_options.add_visible_flag  = (file.has_multiple_object_versions() || file.is_true("force_visible_flag")) && !m_options.use_change_ops;
                     m_options.locations_on_ways = file.is_true("locations_on_ways");
                 }
 
-                XMLOutputFormat(const XMLOutputFormat&) = delete;
-                XMLOutputFormat& operator=(const XMLOutputFormat&) = delete;
-
-                ~XMLOutputFormat() noexcept final = default;
-
                 void write_header(const osmium::io::Header& header) final {
                     std::string out{"<?xml version='1.0' encoding='UTF-8'?>\n"};
 
diff --git a/third_party/libosmium/include/osmium/io/detail/zlib.hpp b/third_party/libosmium/include/osmium/io/detail/zlib.hpp
index b61bf1de580..925966c12be 100644
--- a/third_party/libosmium/include/osmium/io/detail/zlib.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/zlib.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,21 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <string>
+#include <osmium/io/error.hpp>
 
-#include <zlib.h>
+#include <protozero/version.hpp>
 
-#include <protozero/types.hpp>
+#if PROTOZERO_VERSION_CODE >= 10600
+# include <protozero/data_view.hpp>
+#else
+# include <protozero/types.hpp>
+#endif
 
-#include <osmium/io/error.hpp>
-#include <osmium/util/cast.hpp>
+#include <zlib.h>
+
+#include <cassert>
+#include <limits>
+#include <string>
 
 namespace osmium {
 
@@ -58,7 +65,8 @@ namespace osmium {
              * @returns Compressed data.
              */
             inline std::string zlib_compress(const std::string& input) {
-                unsigned long output_size = ::compressBound(osmium::static_cast_with_assert<unsigned long>(input.size()));
+                assert(input.size() < std::numeric_limits<unsigned long>::max());
+                unsigned long output_size = ::compressBound(static_cast<unsigned long>(input.size())); // NOLINT(google-runtime-int)
 
                 std::string output(output_size, '\0');
 
@@ -66,7 +74,7 @@ namespace osmium {
                     reinterpret_cast<unsigned char*>(const_cast<char *>(output.data())),
                     &output_size,
                     reinterpret_cast<const unsigned char*>(input.data()),
-                    osmium::static_cast_with_assert<unsigned long>(input.size())
+                    static_cast<unsigned long>(input.size()) // NOLINT(google-runtime-int)
                 );
 
                 if (result != Z_OK) {
@@ -89,7 +97,7 @@ namespace osmium {
              * @param output Uncompressed result data.
              * @returns Pointer and size to incompressed data.
              */
-            inline protozero::data_view zlib_uncompress_string(const char* input, unsigned long input_size, unsigned long raw_size, std::string& output) {
+            inline protozero::data_view zlib_uncompress_string(const char* input, unsigned long input_size, unsigned long raw_size, std::string& output) { // NOLINT(google-runtime-int)
                 output.resize(raw_size);
 
                 const auto result = ::uncompress(
diff --git a/third_party/libosmium/include/osmium/io/error.hpp b/third_party/libosmium/include/osmium/io/error.hpp
index f02a298eb76..742df53b3a1 100644
--- a/third_party/libosmium/include/osmium/io/error.hpp
+++ b/third_party/libosmium/include/osmium/io/error.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/file.hpp b/third_party/libosmium/include/osmium/io/file.hpp
index 4b40924081f..5bfd4ff076e 100644
--- a/third_party/libosmium/include/osmium/io/file.hpp
+++ b/third_party/libosmium/include/osmium/io/file.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/util/options.hpp>
+
 #include <cstddef>
 #include <sstream>
 #include <string>
 #include <vector>
 
-#include <osmium/io/error.hpp>
-#include <osmium/io/file_format.hpp>
-#include <osmium/io/file_compression.hpp>
-#include <osmium/util/options.hpp>
-
 namespace osmium {
 
     /**
@@ -69,22 +69,22 @@ namespace osmium {
          *
          * If the filename is empty or "-", this means stdin or stdout is used.
          */
-        class File : public osmium::util::Options {
+        class File : public osmium::Options {
 
         private:
 
-            std::string m_filename;
+            std::string m_filename{};
 
-            const char* m_buffer;
-            size_t m_buffer_size;
+            const char* m_buffer = nullptr;
+            size_t m_buffer_size = 0;
 
             std::string m_format_string;
 
-            file_format m_file_format {file_format::unknown};
+            file_format m_file_format = file_format::unknown;
 
-            file_compression m_file_compression {file_compression::none};
+            file_compression m_file_compression = file_compression::none;
 
-            bool m_has_multiple_object_versions {false};
+            bool m_has_multiple_object_versions = false;
 
         public:
 
@@ -100,12 +100,9 @@ namespace osmium {
              *               empty the format will be deduced from the suffix
              *               of the filename.
              */
-            explicit File(const std::string& filename = "", const std::string& format = "") :
-                Options(),
-                m_filename(filename),
-                m_buffer(nullptr),
-                m_buffer_size(0),
-                m_format_string(format) {
+            explicit File(std::string filename = "", std::string format = "") :
+                m_filename(std::move(filename)),
+                m_format_string(std::move(format)) {
 
                 // stdin/stdout
                 if (m_filename == "-") {
@@ -118,10 +115,10 @@ namespace osmium {
                     m_file_format = file_format::xml;
                 }
 
-                if (format.empty()) {
+                if (m_format_string.empty()) {
                     detect_format_from_suffix(m_filename);
                 } else {
-                    parse_format(format);
+                    parse_format(m_format_string);
                 }
             }
 
@@ -135,24 +132,14 @@ namespace osmium {
              *               parse_format() function for details.
              */
             explicit File(const char* buffer, size_t size, const std::string& format = "") :
-                Options(),
-                m_filename(),
                 m_buffer(buffer),
                 m_buffer_size(size),
                 m_format_string(format) {
-                if (format != "") {
+                if (!format.empty()) {
                     parse_format(format);
                 }
             }
 
-            File(const File&) = default;
-            File& operator=(const File&) = default;
-
-            File(File&&) = default;
-            File& operator=(File&&) = default;
-
-            ~File() = default;
-
             const char* buffer() const noexcept {
                 return m_buffer;
             }
@@ -176,7 +163,7 @@ namespace osmium {
                     if (pos == std::string::npos) {
                         set(option, true);
                     } else {
-                        std::string value{option.substr(pos+1)};
+                        std::string value{option.substr(pos + 1)};
                         option.erase(pos);
                         set(option, value);
                     }
@@ -274,7 +261,7 @@ namespace osmium {
             const File& check() const {
                 if (m_file_format == file_format::unknown) {
                     std::string msg{"Could not detect file format"};
-                    if (!m_format_string.empty())  {
+                    if (!m_format_string.empty()) {
                         msg += " from format string '";
                         msg += m_format_string;
                         msg += "'";
diff --git a/third_party/libosmium/include/osmium/io/file_compression.hpp b/third_party/libosmium/include/osmium/io/file_compression.hpp
index 407558dc620..11ea70d94a8 100644
--- a/third_party/libosmium/include/osmium/io/file_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/file_compression.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/file_format.hpp b/third_party/libosmium/include/osmium/io/file_format.hpp
index cde12996ce4..4c5b3af2c87 100644
--- a/third_party/libosmium/include/osmium/io/file_format.hpp
+++ b/third_party/libosmium/include/osmium/io/file_format.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -47,7 +47,8 @@ namespace osmium {
             json      = 4,
             o5m       = 5,
             debug     = 6,
-            blackhole = 7
+            blackhole = 7,
+            last      = 7 // must have the same value as the last real value
         };
 
         enum class read_meta {
@@ -55,7 +56,7 @@ namespace osmium {
             yes = 1
         };
 
-        inline const char* as_string(file_format format) {
+        inline const char* as_string(const file_format format) noexcept {
             switch (format) {
                 case file_format::xml:
                     return "XML";
diff --git a/third_party/libosmium/include/osmium/io/gzip_compression.hpp b/third_party/libosmium/include/osmium/io/gzip_compression.hpp
index 49300d36517..687f7be2939 100644
--- a/third_party/libosmium/include/osmium/io/gzip_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/gzip_compression.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,24 +42,25 @@ DEALINGS IN THE SOFTWARE.
  * @attention If you include this file, you'll need to link with `libz`.
  */
 
+#include <osmium/io/compression.hpp>
+#include <osmium/io/detail/read_write.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/io/writer_options.hpp>
+#include <osmium/util/compatibility.hpp>
+
+#include <zlib.h>
+
+#include <cassert>
+#include <cerrno>
 #include <cstddef>
+#include <limits>
 #include <string>
 
 #ifndef _MSC_VER
 # include <unistd.h>
 #endif
 
-#include <errno.h>
-#include <zlib.h>
-
-#include <osmium/io/compression.hpp>
-#include <osmium/io/error.hpp>
-#include <osmium/io/file_compression.hpp>
-#include <osmium/io/detail/read_write.hpp>
-#include <osmium/io/writer_options.hpp>
-#include <osmium/util/cast.hpp>
-#include <osmium/util/compatibility.hpp>
-
 namespace osmium {
 
     /**
@@ -114,6 +115,12 @@ namespace osmium {
                 }
             }
 
+            GzipCompressor(const GzipCompressor&) = delete;
+            GzipCompressor& operator=(const GzipCompressor&) = delete;
+
+            GzipCompressor(GzipCompressor&&) = delete;
+            GzipCompressor& operator=(GzipCompressor&&) = delete;
+
             ~GzipCompressor() noexcept final {
                 try {
                     close();
@@ -124,7 +131,8 @@ namespace osmium {
 
             void write(const std::string& data) final {
                 if (!data.empty()) {
-                    const int nwrite = ::gzwrite(m_gzfile, data.data(), static_cast_with_assert<unsigned int>(data.size()));
+                    assert(data.size() < std::numeric_limits<unsigned int>::max());
+                    const int nwrite = ::gzwrite(m_gzfile, data.data(), static_cast<unsigned int>(data.size()));
                     if (nwrite == 0) {
                         detail::throw_gzip_error(m_gzfile, "write failed");
                     }
@@ -154,13 +162,18 @@ namespace osmium {
         public:
 
             explicit GzipDecompressor(int fd) :
-                Decompressor(),
                 m_gzfile(::gzdopen(fd, "r")) {
                 if (!m_gzfile) {
                     detail::throw_gzip_error(m_gzfile, "read initialization failed");
                 }
             }
 
+            GzipDecompressor(const GzipDecompressor&) = delete;
+            GzipDecompressor& operator=(const GzipDecompressor&) = delete;
+
+            GzipDecompressor(GzipDecompressor&&) = delete;
+            GzipDecompressor& operator=(GzipDecompressor&&) = delete;
+
             ~GzipDecompressor() noexcept final {
                 try {
                     close();
@@ -171,7 +184,8 @@ namespace osmium {
 
             std::string read() final {
                 std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0');
-                int nread = ::gzread(m_gzfile, const_cast<char*>(buffer.data()), static_cast_with_assert<unsigned int>(buffer.size()));
+                assert(buffer.size() < std::numeric_limits<unsigned int>::max());
+                int nread = ::gzread(m_gzfile, const_cast<char*>(buffer.data()), static_cast<unsigned int>(buffer.size()));
                 if (nread < 0) {
                     detail::throw_gzip_error(m_gzfile, "read failed");
                 }
@@ -207,8 +221,9 @@ namespace osmium {
                 m_buffer_size(size),
                 m_zstream() {
                 m_zstream.next_in = reinterpret_cast<unsigned char*>(const_cast<char*>(buffer));
-                m_zstream.avail_in = static_cast_with_assert<unsigned int>(size);
-                const int result = inflateInit2(&m_zstream, MAX_WBITS | 32);
+                assert(size < std::numeric_limits<unsigned int>::max());
+                m_zstream.avail_in = static_cast<unsigned int>(size);
+                const int result = inflateInit2(&m_zstream, MAX_WBITS | 32); // NOLINT(hicpp-signed-bitwise)
                 if (result != Z_OK) {
                     std::string message{"gzip error: decompression init failed: "};
                     if (m_zstream.msg) {
@@ -218,6 +233,12 @@ namespace osmium {
                 }
             }
 
+            GzipBufferDecompressor(const GzipBufferDecompressor&) = delete;
+            GzipBufferDecompressor& operator=(const GzipBufferDecompressor&) = delete;
+
+            GzipBufferDecompressor(GzipBufferDecompressor&&) = delete;
+            GzipBufferDecompressor& operator=(GzipBufferDecompressor&&) = delete;
+
             ~GzipBufferDecompressor() noexcept final {
                 try {
                     close();
@@ -249,7 +270,7 @@ namespace osmium {
                         throw osmium::gzip_error{message, result};
                     }
 
-                    output.resize(static_cast<unsigned long>(m_zstream.next_out - reinterpret_cast<const unsigned char*>(output.data())));
+                    output.resize(static_cast<std::size_t>(m_zstream.next_out - reinterpret_cast<const unsigned char*>(output.data())));
                 }
 
                 return output;
diff --git a/third_party/libosmium/include/osmium/io/header.hpp b/third_party/libosmium/include/osmium/io/header.hpp
index f52929415f0..ff5d89b2fb7 100644
--- a/third_party/libosmium/include/osmium/io/header.hpp
+++ b/third_party/libosmium/include/osmium/io/header.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <initializer_list>
-#include <vector>
-
 #include <osmium/osm/box.hpp>
 #include <osmium/util/options.hpp>
 
+#include <initializer_list>
+#include <vector>
+
 namespace osmium {
 
     namespace io {
@@ -65,30 +65,24 @@ namespace osmium {
          * specially. The the Options parent class for details on how to
          * set and get those key-value pairs.
          */
-        class Header : public osmium::util::Options {
+        class Header : public osmium::Options {
 
             /// Bounding boxes
-            std::vector<osmium::Box> m_boxes;
+            std::vector<osmium::Box> m_boxes{};
 
             /**
              * Are there possibly multiple versions of the same object in
              * this stream of objects? This should be true for history files
              * and for change files, but not for normal OSM data files.
              */
-            bool m_has_multiple_object_versions;
+            bool m_has_multiple_object_versions = false;
 
         public:
 
-            Header() :
-                Options(),
-                m_boxes(),
-                m_has_multiple_object_versions(false) {
-            }
+            Header() = default;
 
-            explicit Header(const std::initializer_list<osmium::util::Options::value_type>& values) :
-                Options(values),
-                m_boxes(),
-                m_has_multiple_object_versions(false) {
+            Header(const std::initializer_list<osmium::Options::value_type>& values) :
+                Options(values) {
             }
 
             /**
diff --git a/third_party/libosmium/include/osmium/io/input_iterator.hpp b/third_party/libosmium/include/osmium/io/input_iterator.hpp
index d35f58ca5d4..d89e48e4515 100644
--- a/third_party/libosmium/include/osmium/io/input_iterator.hpp
+++ b/third_party/libosmium/include/osmium/io/input_iterator.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/item.hpp>
+
 #include <cassert>
 #include <cstddef>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 
-#include <osmium/memory/buffer.hpp>
-#include <osmium/memory/item.hpp>
-
 namespace osmium {
 
     namespace io {
@@ -60,7 +60,7 @@ namespace osmium {
 
             TSource* m_source;
             std::shared_ptr<osmium::memory::Buffer> m_buffer;
-            item_iterator m_iter {};
+            item_iterator m_iter{};
 
             void update_buffer() {
                 do {
diff --git a/third_party/libosmium/include/osmium/io/o5m_input.hpp b/third_party/libosmium/include/osmium/io/o5m_input.hpp
index 405bd8cd3db..08390ba4117 100644
--- a/third_party/libosmium/include/osmium/io/o5m_input.hpp
+++ b/third_party/libosmium/include/osmium/io/o5m_input.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -39,7 +39,7 @@ DEALINGS IN THE SOFTWARE.
  * Include this file if you want to read OSM o5m and o5c files.
  */
 
-#include <osmium/io/reader.hpp> // IWYU pragma: export
 #include <osmium/io/detail/o5m_input_format.hpp> // IWYU pragma: export
+#include <osmium/io/reader.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_O5M_INPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/opl_input.hpp b/third_party/libosmium/include/osmium/io/opl_input.hpp
index 954f8f61d70..7b75fbfea20 100644
--- a/third_party/libosmium/include/osmium/io/opl_input.hpp
+++ b/third_party/libosmium/include/osmium/io/opl_input.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -40,7 +40,7 @@ DEALINGS IN THE SOFTWARE.
  *
  */
 
-#include <osmium/io/reader.hpp> // IWYU pragma: export
 #include <osmium/io/detail/opl_input_format.hpp> // IWYU pragma: export
+#include <osmium/io/reader.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_OPL_INPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/opl_output.hpp b/third_party/libosmium/include/osmium/io/opl_output.hpp
index d833052cff0..7fa4489694d 100644
--- a/third_party/libosmium/include/osmium/io/opl_output.hpp
+++ b/third_party/libosmium/include/osmium/io/opl_output.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,7 +33,7 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/io/writer.hpp> // IWYU pragma: export
 #include <osmium/io/detail/opl_output_format.hpp> // IWYU pragma: export
+#include <osmium/io/writer.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_OPL_OUTPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/output_iterator.hpp b/third_party/libosmium/include/osmium/io/output_iterator.hpp
index d0e9d3ff002..1901281464d 100644
--- a/third_party/libosmium/include/osmium/io/output_iterator.hpp
+++ b/third_party/libosmium/include/osmium/io/output_iterator.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-#include <iterator>
-
 #include <osmium/osm/diff_object.hpp>
 #include <osmium/util/compatibility.hpp>
 
+#include <cstddef>
+#include <iterator>
+
 namespace osmium {
 
     namespace memory {
@@ -75,14 +75,6 @@ namespace osmium {
                 destination.set_buffer_size(buffer_size);
             }
 
-            OutputIterator(const OutputIterator&) = default;
-            OutputIterator(OutputIterator&&) = default;
-
-            OutputIterator& operator=(const OutputIterator&) = default;
-            OutputIterator& operator=(OutputIterator&&) = default;
-
-            ~OutputIterator() = default;
-
             /**
              * @deprecated
              * Calling OutputIterator<Writer>::flush() is usually not
@@ -98,18 +90,23 @@ namespace osmium {
             }
 
             OutputIterator& operator=(const osmium::DiffObject& diff) {
-                return this->operator=(diff.curr());
+                this->operator=(diff.curr());
+                return *this;
+            }
+
+            OutputIterator& operator*() noexcept {
+                return *this;
             }
 
-            OutputIterator& operator*() {
+            const OutputIterator& operator*() const noexcept {
                 return *this;
             }
 
-            OutputIterator& operator++() {
+            OutputIterator& operator++() noexcept {
                 return *this;
             }
 
-            OutputIterator& operator++(int) {
+            OutputIterator operator++(int) const noexcept {
                 return *this;
             }
 
diff --git a/third_party/libosmium/include/osmium/io/overwrite.hpp b/third_party/libosmium/include/osmium/io/overwrite.hpp
index 0837ff53b40..c8fa539bcf2 100644
--- a/third_party/libosmium/include/osmium/io/overwrite.hpp
+++ b/third_party/libosmium/include/osmium/io/overwrite.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/pbf_input.hpp b/third_party/libosmium/include/osmium/io/pbf_input.hpp
index 02b22778700..c745d36cb56 100644
--- a/third_party/libosmium/include/osmium/io/pbf_input.hpp
+++ b/third_party/libosmium/include/osmium/io/pbf_input.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,7 +42,7 @@ DEALINGS IN THE SOFTWARE.
  *            `libz`, and enable multithreading.
  */
 
-#include <osmium/io/reader.hpp> // IWYU pragma: export
 #include <osmium/io/detail/pbf_input_format.hpp> // IWYU pragma: export
+#include <osmium/io/reader.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_PBF_INPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/pbf_output.hpp b/third_party/libosmium/include/osmium/io/pbf_output.hpp
index db493a16f94..4e493f442f7 100644
--- a/third_party/libosmium/include/osmium/io/pbf_output.hpp
+++ b/third_party/libosmium/include/osmium/io/pbf_output.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,7 +42,7 @@ DEALINGS IN THE SOFTWARE.
  *            `libz`, and enable multithreading.
  */
 
-#include <osmium/io/writer.hpp> // IWYU pragma: export
 #include <osmium/io/detail/pbf_output_format.hpp> // IWYU pragma: export
+#include <osmium/io/writer.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_PBF_OUTPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/reader.hpp b/third_party/libosmium/include/osmium/io/reader.hpp
index 728693375d2..9ffacb935f4 100644
--- a/third_party/libosmium/include/osmium/io/reader.hpp
+++ b/third_party/libosmium/include/osmium/io/reader.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,20 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/io/compression.hpp>
+#include <osmium/io/detail/input_format.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/io/detail/read_thread.hpp>
+#include <osmium/io/detail/read_write.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/header.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/entity_bits.hpp>
+#include <osmium/thread/pool.hpp>
+#include <osmium/thread/util.hpp>
+#include <osmium/util/config.hpp>
+
 #include <cerrno>
 #include <cstdlib>
 #include <fcntl.h>
@@ -51,20 +65,6 @@ DEALINGS IN THE SOFTWARE.
 # include <unistd.h>
 #endif
 
-#include <osmium/io/compression.hpp>
-#include <osmium/io/detail/input_format.hpp>
-#include <osmium/io/detail/read_thread.hpp>
-#include <osmium/io/detail/read_write.hpp>
-#include <osmium/io/detail/queue_util.hpp>
-#include <osmium/io/error.hpp>
-#include <osmium/io/file.hpp>
-#include <osmium/io/header.hpp>
-#include <osmium/memory/buffer.hpp>
-#include <osmium/osm/entity_bits.hpp>
-#include <osmium/thread/pool.hpp>
-#include <osmium/thread/util.hpp>
-#include <osmium/util/config.hpp>
-
 namespace osmium {
 
     namespace io {
@@ -102,9 +102,9 @@ namespace osmium {
                 error  = 1, // some error occurred while reading
                 closed = 2, // close() called
                 eof    = 3  // eof of file was reached without error
-            } m_status;
+            } m_status = status::okay;
 
-            int m_childpid;
+            int m_childpid = 0;
 
             detail::future_string_queue_type m_input_queue;
 
@@ -115,12 +115,12 @@ namespace osmium {
             detail::future_buffer_queue_type m_osmdata_queue;
             detail::queue_wrapper<osmium::memory::Buffer> m_osmdata_queue_wrapper;
 
-            std::future<osmium::io::Header> m_header_future;
-            osmium::io::Header m_header;
+            std::future<osmium::io::Header> m_header_future{};
+            osmium::io::Header m_header{};
 
-            osmium::thread::thread_handler m_thread;
+            osmium::thread::thread_handler m_thread{};
 
-            std::size_t m_file_size;
+            std::size_t m_file_size = 0;
 
             osmium::osm_entity_bits::type m_read_which_entities = osmium::osm_entity_bits::all;
             osmium::io::read_meta m_read_metadata = osmium::io::read_meta::yes;
@@ -254,8 +254,6 @@ namespace osmium {
             explicit Reader(const osmium::io::File& file, TArgs&&... args) :
                 m_file(file.check()),
                 m_creator(detail::ParserFactory::instance().get_creator_function(m_file)),
-                m_status(status::okay),
-                m_childpid(0),
                 m_input_queue(detail::get_input_queue_size(), "raw_input"),
                 m_decompressor(m_file.buffer() ?
                     osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), m_file.buffer(), m_file.buffer_size()) :
@@ -263,9 +261,6 @@ namespace osmium {
                 m_read_thread_manager(*m_decompressor, m_input_queue),
                 m_osmdata_queue(detail::get_osmdata_queue_size(), "parser_results"),
                 m_osmdata_queue_wrapper(m_osmdata_queue),
-                m_header_future(),
-                m_header(),
-                m_thread(),
                 m_file_size(m_decompressor->file_size()) {
 
                 (void)std::initializer_list<int>{
@@ -294,8 +289,8 @@ namespace osmium {
             Reader(const Reader&) = delete;
             Reader& operator=(const Reader&) = delete;
 
-            Reader(Reader&&) = default;
-            Reader& operator=(Reader&&) = default;
+            Reader(Reader&&) = delete;
+            Reader& operator=(Reader&&) = delete;
 
             ~Reader() noexcept {
                 try {
@@ -332,7 +327,7 @@ namespace osmium {
                     const pid_t pid = ::waitpid(m_childpid, &status, 0);
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
-                    if (pid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+                    if (pid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) { // NOLINT(hicpp-signed-bitwise)
                         throw std::system_error{errno, std::system_category(), "subprocess returned error"};
                     }
 #pragma GCC diagnostic pop
diff --git a/third_party/libosmium/include/osmium/io/reader_iterator.hpp b/third_party/libosmium/include/osmium/io/reader_iterator.hpp
index 1fc69fc19f6..242a7260e67 100644
--- a/third_party/libosmium/include/osmium/io/reader_iterator.hpp
+++ b/third_party/libosmium/include/osmium/io/reader_iterator.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,19 +33,23 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/io/reader.hpp>
 #include <osmium/io/input_iterator.hpp>
+#include <osmium/io/reader.hpp>
+
+namespace osmium {
+
+    namespace io {
 
-namespace std {
+        inline InputIterator<Reader> begin(Reader& reader) {
+            return InputIterator<Reader>(reader);
+        }
 
-    inline osmium::io::InputIterator<osmium::io::Reader> begin(osmium::io::Reader& reader) {
-        return osmium::io::InputIterator<osmium::io::Reader>(reader);
-    }
+        inline InputIterator<Reader> end(Reader& /*reader*/) {
+            return InputIterator<Reader>();
+        }
 
-    inline osmium::io::InputIterator<osmium::io::Reader> end(osmium::io::Reader&) {
-        return osmium::io::InputIterator<osmium::io::Reader>();
-    }
+    } // namespace io
 
-} // namespace std
+} // namespace osmium
 
 #endif // OSMIUM_IO_READER_ITERATOR_HPP
diff --git a/third_party/libosmium/include/osmium/io/reader_with_progress_bar.hpp b/third_party/libosmium/include/osmium/io/reader_with_progress_bar.hpp
new file mode 100644
index 00000000000..9bd8d3c08df
--- /dev/null
+++ b/third_party/libosmium/include/osmium/io/reader_with_progress_bar.hpp
@@ -0,0 +1,101 @@
+#ifndef OSMIUM_IO_READER_WITH_PROGRESS_BAR_HPP
+#define OSMIUM_IO_READER_WITH_PROGRESS_BAR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+*/
+
+#include <osmium/io/input_iterator.hpp>
+#include <osmium/io/reader.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/util/progress_bar.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        /**
+         * Wraps an osmium::io::Reader and an osmium::ProgressBar into
+         * one handy package.
+         */
+        class ReaderWithProgressBar : public Reader {
+
+            ProgressBar m_progress_bar;
+
+        public:
+
+            /**
+             * Constructor.
+             *
+             * @param enable Enable flag for the progress bar.
+             *
+             * All other parameters are forwarded to the Reader.
+             */
+            template <typename... TArgs>
+            ReaderWithProgressBar(bool enable, TArgs&&... args) :
+                Reader(std::forward<TArgs>(args)...),
+                m_progress_bar(file_size(), enable) {
+            }
+
+            /**
+             * Read a buffer from the Reader updating the progress bar in
+             * the process.
+             */
+            osmium::memory::Buffer read() {
+                auto buffer = Reader::read();
+                if (buffer) {
+                    m_progress_bar.update(offset());
+                } else {
+                    m_progress_bar.done();
+                }
+                return buffer;
+            }
+
+            /// Get the underlying ProgressBar object.
+            ProgressBar& progress_bar() noexcept {
+                return m_progress_bar;
+            }
+
+        }; // class ReaderWithProgressBar
+
+        inline InputIterator<ReaderWithProgressBar> begin(ReaderWithProgressBar& reader) {
+            return InputIterator<ReaderWithProgressBar>(reader);
+        }
+
+        inline InputIterator<ReaderWithProgressBar> end(ReaderWithProgressBar& /*reader*/) {
+            return InputIterator<ReaderWithProgressBar>();
+        }
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_READER_WITH_PROGRESS_BAR_HPP
diff --git a/third_party/libosmium/include/osmium/io/writer.hpp b/third_party/libosmium/include/osmium/io/writer.hpp
index dd90a2e5e8d..31f5832eeb4 100644
--- a/third_party/libosmium/include/osmium/io/writer.hpp
+++ b/third_party/libosmium/include/osmium/io/writer.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cstddef>
-#include <exception>
-#include <functional>
-#include <future>
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <utility>
-
 #include <osmium/io/compression.hpp>
 #include <osmium/io/detail/output_format.hpp>
 #include <osmium/io/detail/queue_util.hpp>
@@ -58,6 +48,16 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/util/config.hpp>
 #include <osmium/version.hpp>
 
+#include <cassert>
+#include <cstddef>
+#include <exception>
+#include <functional>
+#include <future>
+#include <initializer_list>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace osmium {
 
     namespace memory {
@@ -104,23 +104,23 @@ namespace osmium {
 
             osmium::io::File m_file;
 
-            detail::future_string_queue_type m_output_queue;
+            detail::future_string_queue_type m_output_queue{detail::get_output_queue_size(), "raw_output"};
 
-            std::unique_ptr<osmium::io::detail::OutputFormat> m_output;
+            std::unique_ptr<osmium::io::detail::OutputFormat> m_output{nullptr};
 
-            osmium::memory::Buffer m_buffer;
+            osmium::memory::Buffer m_buffer{};
 
-            size_t m_buffer_size;
+            size_t m_buffer_size = default_buffer_size;
 
-            std::future<bool> m_write_future;
+            std::future<bool> m_write_future{};
 
-            osmium::thread::thread_handler m_thread;
+            osmium::thread::thread_handler m_thread{};
 
             enum class status {
                 okay   = 0, // normal writing
                 error  = 1, // some error occurred while writing
                 closed = 2  // close() called successfully
-            } m_status;
+            } m_status = status::okay;
 
             // This function will run in a separate thread.
             static void write_thread(detail::future_string_queue_type& output_queue,
@@ -227,14 +227,7 @@ namespace osmium {
              */
             template <typename... TArgs>
             explicit Writer(const osmium::io::File& file, TArgs&&... args) :
-                m_file(file.check()),
-                m_output_queue(detail::get_output_queue_size(), "raw_output"),
-                m_output(nullptr),
-                m_buffer(),
-                m_buffer_size(default_buffer_size),
-                m_write_future(),
-                m_thread(),
-                m_status(status::okay) {
+                m_file(file.check()) {
                 assert(!m_file.buffer()); // XXX can't handle pseudo-files
 
                 options_type options;
@@ -248,7 +241,7 @@ namespace osmium {
 
                 m_output = osmium::io::detail::OutputFormatFactory::instance().create_output(*options.pool, m_file, m_output_queue);
 
-                if (options.header.get("generator") == "") {
+                if (options.header.get("generator").empty()) {
                     options.header.set("generator", "libosmium/" LIBOSMIUM_VERSION_STRING);
                 }
 
@@ -279,8 +272,8 @@ namespace osmium {
             Writer(const Writer&) = delete;
             Writer& operator=(const Writer&) = delete;
 
-            Writer(Writer&&) = default;
-            Writer& operator=(Writer&&) = default;
+            Writer(Writer&&) = delete;
+            Writer& operator=(Writer&&) = delete;
 
             ~Writer() noexcept {
                 try {
diff --git a/third_party/libosmium/include/osmium/io/writer_options.hpp b/third_party/libosmium/include/osmium/io/writer_options.hpp
index bcc52fdd931..d73c905dab4 100644
--- a/third_party/libosmium/include/osmium/io/writer_options.hpp
+++ b/third_party/libosmium/include/osmium/io/writer_options.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/xml_input.hpp b/third_party/libosmium/include/osmium/io/xml_input.hpp
index e20bdde432a..9de7df2eab7 100644
--- a/third_party/libosmium/include/osmium/io/xml_input.hpp
+++ b/third_party/libosmium/include/osmium/io/xml_input.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,7 +42,7 @@ DEALINGS IN THE SOFTWARE.
  *            `libexpat`, and enable multithreading.
  */
 
-#include <osmium/io/reader.hpp> // IWYU pragma: export
 #include <osmium/io/detail/xml_input_format.hpp> // IWYU pragma: export
+#include <osmium/io/reader.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_XML_INPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/xml_output.hpp b/third_party/libosmium/include/osmium/io/xml_output.hpp
index cfb5e8afe5e..3c4be9b26da 100644
--- a/third_party/libosmium/include/osmium/io/xml_output.hpp
+++ b/third_party/libosmium/include/osmium/io/xml_output.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -41,7 +41,7 @@ DEALINGS IN THE SOFTWARE.
  * @attention If you include this file, you'll need to enable multithreading.
  */
 
-#include <osmium/io/writer.hpp> // IWYU pragma: export
 #include <osmium/io/detail/xml_output_format.hpp> // IWYU pragma: export
+#include <osmium/io/writer.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_XML_OUTPUT_HPP
diff --git a/third_party/libosmium/include/osmium/memory/buffer.hpp b/third_party/libosmium/include/osmium/memory/buffer.hpp
index deaee42f3aa..392c6bf7642 100644
--- a/third_party/libosmium/include/osmium/memory/buffer.hpp
+++ b/third_party/libosmium/include/osmium/memory/buffer.hpp
@@ -1,12 +1,11 @@
 #ifndef OSMIUM_MEMORY_BUFFER_HPP
 #define OSMIUM_MEMORY_BUFFER_HPP
 
-#include <iostream>
 /*
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,6 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/item.hpp>
+#include <osmium/memory/item_iterator.hpp>
+#include <osmium/osm/entity.hpp>
+#include <osmium/util/compatibility.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -44,11 +48,6 @@ DEALINGS IN THE SOFTWARE.
 #include <stdexcept>
 #include <utility>
 
-#include <osmium/memory/item.hpp>
-#include <osmium/memory/item_iterator.hpp>
-#include <osmium/osm/entity.hpp>
-#include <osmium/util/compatibility.hpp>
-
 namespace osmium {
 
     /**
@@ -110,10 +109,10 @@ namespace osmium {
         private:
 
             std::unique_ptr<unsigned char[]> m_memory;
-            unsigned char* m_data;
-            std::size_t m_capacity;
-            std::size_t m_written;
-            std::size_t m_committed;
+            unsigned char* m_data = nullptr;
+            std::size_t m_capacity = 0;
+            std::size_t m_written = 0;
+            std::size_t m_committed = 0;
 #ifndef NDEBUG
             uint8_t m_builder_count = 0;
 #endif
@@ -140,11 +139,7 @@ namespace osmium {
              * buffer.
              */
             Buffer() noexcept :
-                m_memory(),
-                m_data(nullptr),
-                m_capacity(0),
-                m_written(0),
-                m_committed(0) {
+                m_memory() {
             }
 
             /**
@@ -213,8 +208,6 @@ namespace osmium {
                 m_memory(new unsigned char[calculate_capacity(capacity)]),
                 m_data(m_memory.get()),
                 m_capacity(calculate_capacity(capacity)),
-                m_written(0),
-                m_committed(0),
                 m_auto_grow(auto_grow) {
             }
 
@@ -582,7 +575,7 @@ namespace osmium {
              */
             iterator begin() {
                 assert(m_data && "This must be a valid buffer");
-                return iterator(m_data, m_data + m_committed);
+                return {m_data, m_data + m_committed};
             }
 
             /**
@@ -597,7 +590,7 @@ namespace osmium {
             template <typename T>
             t_iterator<T> get_iterator(std::size_t offset) {
                 assert(m_data && "This must be a valid buffer");
-                return t_iterator<T>(m_data + offset, m_data + m_committed);
+                return {m_data + offset, m_data + m_committed};
             }
 
             /**
@@ -611,7 +604,7 @@ namespace osmium {
              */
             iterator get_iterator(std::size_t offset) {
                 assert(m_data && "This must be a valid buffer");
-                return iterator(m_data + offset, m_data + m_committed);
+                return {m_data + offset, m_data + m_committed};
             }
 
             /**
@@ -625,7 +618,7 @@ namespace osmium {
             template <typename T>
             t_iterator<T> end() {
                 assert(m_data && "This must be a valid buffer");
-                return t_iterator<T>(m_data + m_committed, m_data + m_committed);
+                return {m_data + m_committed, m_data + m_committed};
             }
 
             /**
@@ -638,40 +631,40 @@ namespace osmium {
              */
             iterator end() {
                 assert(m_data && "This must be a valid buffer");
-                return iterator(m_data + m_committed, m_data + m_committed);
+                return {m_data + m_committed, m_data + m_committed};
             }
 
             template <typename T>
             t_const_iterator<T> cbegin() const {
                 assert(m_data && "This must be a valid buffer");
-                return t_const_iterator<T>(m_data, m_data + m_committed);
+                return {m_data, m_data + m_committed};
             }
 
             const_iterator cbegin() const {
                 assert(m_data && "This must be a valid buffer");
-                return const_iterator(m_data, m_data + m_committed);
+                return {m_data, m_data + m_committed};
             }
 
             template <typename T>
             t_const_iterator<T> get_iterator(std::size_t offset) const {
                 assert(m_data && "This must be a valid buffer");
-                return t_const_iterator<T>(m_data + offset, m_data + m_committed);
+                return {m_data + offset, m_data + m_committed};
             }
 
             const_iterator get_iterator(std::size_t offset) const {
                 assert(m_data && "This must be a valid buffer");
-                return const_iterator(m_data + offset, m_data + m_committed);
+                return {m_data + offset, m_data + m_committed};
             }
 
             template <typename T>
             t_const_iterator<T> cend() const {
                 assert(m_data && "This must be a valid buffer");
-                return t_const_iterator<T>(m_data + m_committed, m_data + m_committed);
+                return {m_data + m_committed, m_data + m_committed};
             }
 
             const_iterator cend() const {
                 assert(m_data && "This must be a valid buffer");
-                return const_iterator(m_data + m_committed, m_data + m_committed);
+                return {m_data + m_committed, m_data + m_committed};
             }
 
             template <typename T>
@@ -778,7 +771,7 @@ namespace osmium {
         }
 
         inline bool operator!=(const Buffer& lhs, const Buffer& rhs) noexcept {
-            return ! (lhs == rhs);
+            return !(lhs == rhs);
         }
 
     } // namespace memory
diff --git a/third_party/libosmium/include/osmium/memory/callback_buffer.hpp b/third_party/libosmium/include/osmium/memory/callback_buffer.hpp
index 7e9be73972f..7dd291cb1cf 100644
--- a/third_party/libosmium/include/osmium/memory/callback_buffer.hpp
+++ b/third_party/libosmium/include/osmium/memory/callback_buffer.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/buffer.hpp>
+
 #include <cstddef>
 #include <functional>
 #include <utility>
 
-#include <osmium/memory/buffer.hpp>
-
 namespace osmium {
 
     namespace memory {
@@ -112,11 +112,11 @@ namespace osmium {
              * @param max_buffer_size If the buffer grows beyond this size the
              *                        callback will be called.
              */
-            explicit CallbackBuffer(const callback_func_type& callback, std::size_t initial_buffer_size = default_initial_buffer_size, std::size_t max_buffer_size = default_max_buffer_size) :
+            explicit CallbackBuffer(callback_func_type callback, std::size_t initial_buffer_size = default_initial_buffer_size, std::size_t max_buffer_size = default_max_buffer_size) :
                 m_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes),
                 m_initial_buffer_size(initial_buffer_size),
                 m_max_buffer_size(max_buffer_size),
-                m_callback(callback) {
+                m_callback(std::move(callback)) {
             }
 
             /**
diff --git a/third_party/libosmium/include/osmium/memory/collection.hpp b/third_party/libosmium/include/osmium/memory/collection.hpp
index 21b7ab368d4..5a98b16668e 100644
--- a/third_party/libosmium/include/osmium/memory/collection.hpp
+++ b/third_party/libosmium/include/osmium/memory/collection.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/item.hpp>
+
 #include <iosfwd>
 #include <iterator>
 #include <type_traits>
 
-#include <osmium/memory/item.hpp>
-
 namespace osmium {
 
     namespace memory {
@@ -131,7 +131,7 @@ namespace osmium {
                 return t == itemtype;
             }
 
-            Collection() :
+            Collection() noexcept :
                 Item(sizeof(Collection<TMember, TCollectionItemType>), TCollectionItemType) {
             }
 
diff --git a/third_party/libosmium/include/osmium/memory/item.hpp b/third_party/libosmium/include/osmium/memory/item.hpp
index 0f02df9e7d1..e938127cf59 100644
--- a/third_party/libosmium/include/osmium/memory/item.hpp
+++ b/third_party/libosmium/include/osmium/memory/item.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,8 +36,6 @@ DEALINGS IN THE SOFTWARE.
 #include <cstddef>
 #include <cstdint>
 
-#include <osmium/util/cast.hpp>
-
 namespace osmium {
 
     // forward declaration, see osmium/osm/item_type.hpp for declaration
@@ -78,15 +76,15 @@ namespace osmium {
 
             protected:
 
-                ItemHelper() = default;
+                ItemHelper() noexcept = default;
 
-                ~ItemHelper() = default;
+                ItemHelper(const ItemHelper&) noexcept = default;
+                ItemHelper(ItemHelper&&) noexcept = default;
 
-                ItemHelper(const ItemHelper&) = default;
-                ItemHelper(ItemHelper&&) = default;
+                ItemHelper& operator=(const ItemHelper&) noexcept = default;
+                ItemHelper& operator=(ItemHelper&&) noexcept = default;
 
-                ItemHelper& operator=(const ItemHelper&) = default;
-                ItemHelper& operator=(ItemHelper&&) = default;
+                ~ItemHelper() noexcept = default;
 
             public:
 
@@ -133,12 +131,6 @@ namespace osmium {
                 m_padding(0) {
             }
 
-            Item(const Item&) = delete;
-            Item(Item&&) = delete;
-
-            Item& operator=(const Item&) = delete;
-            Item& operator=(Item&&) = delete;
-
             Item& set_type(const item_type item_type) noexcept {
                 m_type = item_type;
                 return *this;
@@ -146,6 +138,14 @@ namespace osmium {
 
         public:
 
+            Item(const Item&) = delete;
+            Item& operator=(const Item&) = delete;
+
+            Item(Item&&) = delete;
+            Item& operator=(Item&&) = delete;
+
+            ~Item() noexcept = default;
+
             constexpr static bool is_compatible_to(osmium::item_type /*t*/) noexcept {
                 return true;
             }
@@ -163,7 +163,7 @@ namespace osmium {
             }
 
             item_size_type padded_size() const {
-                return static_cast_with_assert<item_size_type>(padded_length(m_size));
+                return static_cast<item_size_type>(padded_length(m_size));
             }
 
             item_type type() const noexcept {
diff --git a/third_party/libosmium/include/osmium/memory/item_iterator.hpp b/third_party/libosmium/include/osmium/memory/item_iterator.hpp
index 3cab11d8759..5cbe9cffc97 100644
--- a/third_party/libosmium/include/osmium/memory/item_iterator.hpp
+++ b/third_party/libosmium/include/osmium/memory/item_iterator.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/item.hpp>
+#include <osmium/osm/item_type.hpp>
+
 #include <cassert>
 #include <cstddef>
 #include <iosfwd>
 #include <iterator>
 #include <type_traits>
 
-#include <osmium/memory/item.hpp>
-#include <osmium/osm/item_type.hpp>
-
 namespace osmium {
 
     namespace memory {
@@ -221,10 +221,9 @@ namespace osmium {
             /**
              * Return the number of items in this range.
              *
-             * Note that this methods has worst-case complexity O(n) with n
-             * being the number of items in the underlying range.
+             * Complexity: Linear in the number of items.
              */
-            size_t size() const {
+            size_t size() const noexcept {
                 if (m_begin == m_end) {
                     return 0;
                 }
@@ -234,10 +233,9 @@ namespace osmium {
             /**
              * Is this range empty?
              *
-             * Note that this methods has worst-case complexity O(n) with n
-             * being the number of items in the underlying range.
+             * Complexity: Linear in the number of items.
              */
-            bool empty() const {
+            bool empty() const noexcept {
                 return size() == 0;
             }
 
diff --git a/third_party/libosmium/include/osmium/object_pointer_collection.hpp b/third_party/libosmium/include/osmium/object_pointer_collection.hpp
index 685211d94ce..e519903a114 100644
--- a/third_party/libosmium/include/osmium/object_pointer_collection.hpp
+++ b/third_party/libosmium/include/osmium/object_pointer_collection.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <utility>
-#include <vector>
+#include <osmium/handler.hpp>
+#include <osmium/osm/object.hpp>
 
 #include <boost/iterator/indirect_iterator.hpp>
 
-#include <osmium/handler.hpp>
-#include <osmium/osm/object.hpp>
+#include <algorithm>
+#include <utility>
+#include <vector>
 
 // IWYU pragma: no_forward_declare osmium::OSMObject
 
diff --git a/third_party/libosmium/include/osmium/opl.hpp b/third_party/libosmium/include/osmium/opl.hpp
index 99699149a54..52b705b332b 100644
--- a/third_party/libosmium/include/osmium/opl.hpp
+++ b/third_party/libosmium/include/osmium/opl.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm.hpp b/third_party/libosmium/include/osmium/osm.hpp
index 2a524ff9886..30f024b40c8 100644
--- a/third_party/libosmium/include/osmium/osm.hpp
+++ b/third_party/libosmium/include/osmium/osm.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/area.hpp b/third_party/libosmium/include/osmium/osm/area.hpp
index 12a73bece6e..84b1b491668 100644
--- a/third_party/libosmium/include/osmium/osm/area.hpp
+++ b/third_party/libosmium/include/osmium/osm/area.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cstdlib>
-#include <iterator>
-#include <utility>
-
 #include <osmium/memory/collection.hpp>
 #include <osmium/memory/item.hpp>
 #include <osmium/memory/item_iterator.hpp>
@@ -48,6 +43,11 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/util/compatibility.hpp>
 
+#include <cassert>
+#include <cstdlib>
+#include <iterator>
+#include <utility>
+
 namespace osmium {
 
     namespace builder {
@@ -68,7 +68,7 @@ namespace osmium {
             return t == itemtype;
         }
 
-        OuterRing():
+        OuterRing() :
             NodeRefList(itemtype) {
         }
 
@@ -89,7 +89,7 @@ namespace osmium {
             return t == itemtype;
         }
 
-        InnerRing():
+        InnerRing() :
             NodeRefList(itemtype) {
         }
 
@@ -149,7 +149,7 @@ namespace osmium {
          * Complexity: Constant.
          */
         bool from_way() const noexcept {
-            return (positive_id() & 0x1) == 0;
+            return (positive_id() & 0x1u) == 0;
         }
 
         /**
diff --git a/third_party/libosmium/include/osmium/osm/box.hpp b/third_party/libosmium/include/osmium/osm/box.hpp
index a451e5ae08e..7eb331ac870 100644
--- a/third_party/libosmium/include/osmium/osm/box.hpp
+++ b/third_party/libosmium/include/osmium/osm/box.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/location.hpp>
+
 #include <cassert>
 #include <iosfwd>
 
-#include <osmium/osm/location.hpp>
-
 namespace osmium {
 
     /**
@@ -48,8 +48,8 @@ namespace osmium {
      */
     class Box {
 
-        osmium::Location m_bottom_left;
-        osmium::Location m_top_right;
+        osmium::Location m_bottom_left{};
+        osmium::Location m_top_right{};
 
     public:
 
@@ -57,10 +57,7 @@ namespace osmium {
          * Create undefined Box. Use the extend() function
          * to add actual bounds.
          */
-        constexpr Box() noexcept :
-            m_bottom_left(),
-            m_top_right() {
-        }
+        constexpr Box() noexcept = default;
 
         /**
          * Create box from minimum and maximum coordinates.
@@ -91,12 +88,6 @@ namespace osmium {
             );
         }
 
-        Box(const Box&) = default;
-        Box(Box&&) = default;
-        Box& operator=(const Box&) = default;
-        Box& operator=(Box&&) = default;
-        ~Box() = default;
-
         /**
          * Extend this bounding box by the specified location. If the
          * location is invalid, the bounding box is unchanged. If the
diff --git a/third_party/libosmium/include/osmium/osm/changeset.hpp b/third_party/libosmium/include/osmium/osm/changeset.hpp
index d79ec310343..fab0043028f 100644
--- a/third_party/libosmium/include/osmium/osm/changeset.hpp
+++ b/third_party/libosmium/include/osmium/osm/changeset.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-
 #include <osmium/memory/collection.hpp>
 #include <osmium/memory/item.hpp>
 #include <osmium/osm/box.hpp>
@@ -47,6 +43,10 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/types_from_string.hpp>
 
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
 namespace osmium {
 
     namespace builder {
@@ -65,12 +65,6 @@ namespace osmium {
         changeset_comment_size_type m_text_size;
         string_size_type m_user_size;
 
-        ChangesetComment(const ChangesetComment&) = delete;
-        ChangesetComment(ChangesetComment&&) = delete;
-
-        ChangesetComment& operator=(const ChangesetComment&) = delete;
-        ChangesetComment& operator=(ChangesetComment&&) = delete;
-
         unsigned char* endpos() {
             return data() + osmium::memory::padded_length(sizeof(ChangesetComment) + m_user_size + m_text_size);
         }
@@ -109,6 +103,14 @@ namespace osmium {
             m_user_size(0) {
         }
 
+        ChangesetComment(const ChangesetComment&) = delete;
+        ChangesetComment& operator=(const ChangesetComment&) = delete;
+
+        ChangesetComment(ChangesetComment&&) = delete;
+        ChangesetComment& operator=(ChangesetComment&&) = delete;
+
+        ~ChangesetComment() noexcept = default;
+
         osmium::Timestamp date() const noexcept {
             return m_date;
         }
@@ -131,9 +133,7 @@ namespace osmium {
 
     public:
 
-        ChangesetDiscussion() :
-            osmium::memory::Collection<ChangesetComment, osmium::item_type::changeset_discussion>() {
-        }
+        ChangesetDiscussion() noexcept = default;
 
     }; // class ChangesetDiscussion
 
@@ -255,7 +255,8 @@ namespace osmium {
          * @returns Reference to changeset to make calls chainable.
          */
         Changeset& set_uid(const char* uid) {
-            return set_uid_from_signed(string_to_user_id(uid));
+            m_uid = string_to_uid(uid);
+            return *this;
         }
 
         /// Is this user anonymous?
@@ -440,7 +441,7 @@ namespace osmium {
     }
 
     inline bool operator!=(const Changeset& lhs, const Changeset& rhs) {
-        return ! (lhs == rhs);
+        return !(lhs == rhs);
     }
 
     /**
@@ -455,11 +456,11 @@ namespace osmium {
     }
 
     inline bool operator<=(const Changeset& lhs, const Changeset& rhs) {
-        return ! (rhs < lhs);
+        return !(rhs < lhs);
     }
 
     inline bool operator>=(const Changeset& lhs, const Changeset& rhs) {
-        return ! (lhs < rhs);
+        return !(lhs < rhs);
     }
 
 } // namespace osmium
diff --git a/third_party/libosmium/include/osmium/osm/crc.hpp b/third_party/libosmium/include/osmium/osm/crc.hpp
index c191db93a5c..fd40ccdbaac 100644
--- a/third_party/libosmium/include/osmium/osm/crc.hpp
+++ b/third_party/libosmium/include/osmium/osm/crc.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,8 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-
 #include <osmium/osm/area.hpp>
 #include <osmium/osm/box.hpp>
 #include <osmium/osm/changeset.hpp>
@@ -50,40 +48,42 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/way.hpp>
 #include <osmium/util/endian.hpp>
 
+#include <cstdint>
+
 namespace osmium {
 
-    namespace util {
+    inline namespace util {
 
         inline uint16_t byte_swap_16(uint16_t value) noexcept {
-# if defined(__GNUC__) || defined(__clang__)
+#if defined(__GNUC__) || defined(__clang__)
             return __builtin_bswap16(value);
-# else
+#else
             return (value >> 8) | (value << 8);
-# endif
+#endif
         }
 
         inline uint32_t byte_swap_32(uint32_t value) noexcept {
-# if defined(__GNUC__) || defined(__clang__)
+#if defined(__GNUC__) || defined(__clang__)
             return __builtin_bswap32(value);
-# else
+#else
             return  (value >> 24) |
                    ((value >>  8) & 0x0000FF00) |
                    ((value <<  8) & 0x00FF0000) |
                     (value << 24);
-# endif
+#endif
         }
 
         inline uint64_t byte_swap_64(uint64_t value) noexcept {
-# if defined(__GNUC__) || defined(__clang__)
+#if defined(__GNUC__) || defined(__clang__)
             return __builtin_bswap64(value);
-# else
+#else
             const uint64_t val1 = byte_swap_32(value & 0xFFFFFFFF);
             const uint64_t val2 = byte_swap_32(value >> 32);
             return (val1 << 32) | val2;
-# endif
+#endif
         }
 
-    } // namespace util
+    } // inline namespace util
 
     template <typename TCRC>
     class CRC {
@@ -112,7 +112,7 @@ namespace osmium {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
             m_crc.process_bytes(&value, sizeof(uint16_t));
 #else
-            const uint16_t v = osmium::util::byte_swap_16(value);
+            const uint16_t v = osmium::byte_swap_16(value);
             m_crc.process_bytes(&v, sizeof(uint16_t));
 #endif
         }
@@ -121,7 +121,7 @@ namespace osmium {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
             m_crc.process_bytes(&value, sizeof(uint32_t));
 #else
-            const uint32_t v = osmium::util::byte_swap_32(value);
+            const uint32_t v = osmium::byte_swap_32(value);
             m_crc.process_bytes(&v, sizeof(uint32_t));
 #endif
         }
@@ -130,7 +130,7 @@ namespace osmium {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
             m_crc.process_bytes(&value, sizeof(uint64_t));
 #else
-            const uint64_t v = osmium::util::byte_swap_64(value);
+            const uint64_t v = osmium::byte_swap_64(value);
             m_crc.process_bytes(&v, sizeof(uint64_t));
 #endif
         }
diff --git a/third_party/libosmium/include/osmium/osm/diff_object.hpp b/third_party/libosmium/include/osmium/osm/diff_object.hpp
index cbf1e7cd985..0e3ff3612a9 100644
--- a/third_party/libosmium/include/osmium/osm/diff_object.hpp
+++ b/third_party/libosmium/include/osmium/osm/diff_object.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,13 +33,13 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/object.hpp>
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/osm/types.hpp>
 
+#include <cassert>
+
 namespace osmium {
 
     class Node;
@@ -65,9 +65,9 @@ namespace osmium {
      */
     class DiffObject {
 
-        const osmium::OSMObject* m_prev;
-        const osmium::OSMObject* m_curr;
-        const osmium::OSMObject* m_next;
+        const osmium::OSMObject* m_prev = nullptr;
+        const osmium::OSMObject* m_curr = nullptr;
+        const osmium::OSMObject* m_next = nullptr;
 
     public:
 
@@ -75,11 +75,7 @@ namespace osmium {
          * Default construct an empty DiffObject. Most methods of this class
          * can not be called on empty DiffObjects.
          */
-        DiffObject() noexcept :
-            m_prev(nullptr),
-            m_curr(nullptr),
-            m_next(nullptr) {
-        }
+        DiffObject() noexcept = default;
 
         /**
          * Construct a non-empty DiffObject from the given OSMObjects. All
diff --git a/third_party/libosmium/include/osmium/osm/entity.hpp b/third_party/libosmium/include/osmium/osm/entity.hpp
index 75905c02d7d..4f83462facc 100644
--- a/third_party/libosmium/include/osmium/osm/entity.hpp
+++ b/third_party/libosmium/include/osmium/osm/entity.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -51,7 +51,7 @@ namespace osmium {
 
             // If no subitem of the TSubitem type was found,
             // return a default constructed one.
-            static TSubitem subitem;
+            static TSubitem subitem{};
             return subitem;
         }
 
diff --git a/third_party/libosmium/include/osmium/osm/entity_bits.hpp b/third_party/libosmium/include/osmium/osm/entity_bits.hpp
index 2742bc98eb9..27848a3fc8d 100644
--- a/third_party/libosmium/include/osmium/osm/entity_bits.hpp
+++ b/third_party/libosmium/include/osmium/osm/entity_bits.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/item_type.hpp>
+
 #include <cassert>
 #include <type_traits>
 
-#include <osmium/osm/item_type.hpp>
-
 namespace osmium {
 
     /**
@@ -78,15 +78,15 @@ namespace osmium {
         }; // enum type
 
         inline constexpr type operator|(const type lhs, const type rhs) noexcept {
-            return static_cast<type>(static_cast<int>(lhs) | static_cast<int>(rhs));
+            return static_cast<type>(static_cast<unsigned char>(lhs) | static_cast<unsigned char>(rhs));
         }
 
         inline constexpr type operator&(const type lhs, const type rhs) noexcept {
-            return static_cast<type>(static_cast<int>(lhs) & static_cast<int>(rhs));
+            return static_cast<type>(static_cast<unsigned char>(lhs) & static_cast<unsigned char>(rhs));
         }
 
         inline constexpr type operator~(const type value) noexcept {
-            return all & static_cast<type>(~static_cast<int>(value));
+            return all & static_cast<type>(~static_cast<unsigned char>(value));
         }
 
         inline type& operator|=(type& lhs, const type rhs) noexcept {
@@ -111,7 +111,7 @@ namespace osmium {
             if (ut == 0) {
                 return nothing;
             }
-            return static_cast<osmium::osm_entity_bits::type>(0x1 << (ut - 1));
+            return static_cast<osmium::osm_entity_bits::type>(1u << (ut - 1u));
         }
 
     } // namespace osm_entity_bits
diff --git a/third_party/libosmium/include/osmium/osm/item_type.hpp b/third_party/libosmium/include/osmium/osm/item_type.hpp
index 74d448221f8..4c8f7e1a652 100644
--- a/third_party/libosmium/include/osmium/osm/item_type.hpp
+++ b/third_party/libosmium/include/osmium/osm/item_type.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -68,7 +68,7 @@ namespace osmium {
      */
     inline item_type nwr_index_to_item_type(unsigned int i) noexcept {
         assert(i <= 2);
-        return item_type(i+1);
+        return item_type(i + 1);
     }
 
     /**
@@ -80,7 +80,7 @@ namespace osmium {
      * @returns Index.
      */
     inline unsigned int item_type_to_nwr_index(item_type type) noexcept {
-        unsigned int i = static_cast<unsigned int>(type);
+        const auto i = static_cast<unsigned int>(type);
         assert(i >= 1 && i <= 3);
         return i - 1;
     }
diff --git a/third_party/libosmium/include/osmium/osm/location.hpp b/third_party/libosmium/include/osmium/osm/location.hpp
index f5ae9e5e3c5..af9f01f9e3b 100644
--- a/third_party/libosmium/include/osmium/osm/location.hpp
+++ b/third_party/libosmium/include/osmium/osm/location.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -220,7 +220,7 @@ namespace osmium {
                 v /= 10;
             } while (v != 0);
 
-            while (t-temp < 7) {
+            while (t - temp < 7) {
                 *t++ = '0';
             }
 
@@ -327,12 +327,6 @@ namespace osmium {
             m_y(double_to_fix(lat)) {
         }
 
-        Location(const Location&) = default;
-        Location(Location&&) = default;
-        Location& operator=(const Location&) = default;
-        Location& operator=(Location&&) = default;
-        ~Location() = default;
-
         /**
          * Check whether the coordinates of this location
          * are defined.
@@ -443,19 +437,21 @@ namespace osmium {
 
         Location& set_lon(const char* str) {
             const char** data = &str;
-            m_x = detail::string_to_location_coordinate(data);
+            const auto value = detail::string_to_location_coordinate(data);
             if (**data != '\0') {
                 throw invalid_location{std::string{"characters after coordinate: '"} + *data + "'"};
             }
+            m_x = value;
             return *this;
         }
 
         Location& set_lat(const char* str) {
             const char** data = &str;
-            m_y = detail::string_to_location_coordinate(data);
+            const auto value = detail::string_to_location_coordinate(data);
             if (**data != '\0') {
                 throw invalid_location{std::string{"characters after coordinate: '"} + *data + "'"};
             }
+            m_y = value;
             return *this;
         }
 
@@ -494,7 +490,7 @@ namespace osmium {
     }
 
     inline constexpr bool operator!=(const Location& lhs, const Location& rhs) noexcept {
-        return ! (lhs == rhs);
+        return !(lhs == rhs);
     }
 
     /**
@@ -511,11 +507,11 @@ namespace osmium {
     }
 
     inline constexpr bool operator<=(const Location& lhs, const Location& rhs) noexcept {
-        return ! (rhs < lhs);
+        return !(rhs < lhs);
     }
 
     inline constexpr bool operator>=(const Location& lhs, const Location& rhs) noexcept {
-        return ! (lhs < rhs);
+        return !(lhs < rhs);
     }
 
     /**
@@ -537,14 +533,14 @@ namespace osmium {
 
         template <int N>
         inline size_t hash(const osmium::Location& location) noexcept {
-            return location.x() ^ location.y();
+            return static_cast<uint32_t>(location.x()) ^ static_cast<uint32_t>(location.y());
         }
 
         template <>
         inline size_t hash<8>(const osmium::Location& location) noexcept {
             uint64_t h = location.x();
             h <<= 32;
-            return static_cast<size_t>(h ^ location.y());
+            return static_cast<size_t>(h ^ static_cast<uint64_t>(location.y()));
         }
 
     } // namespace detail
diff --git a/third_party/libosmium/include/osmium/osm/metadata_options.hpp b/third_party/libosmium/include/osmium/osm/metadata_options.hpp
new file mode 100644
index 00000000000..ccb708612fe
--- /dev/null
+++ b/third_party/libosmium/include/osmium/osm/metadata_options.hpp
@@ -0,0 +1,247 @@
+#ifndef OSMIUM_OSM_METADATA_OPTIONS_HPP
+#define OSMIUM_OSM_METADATA_OPTIONS_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+*/
+
+#include <osmium/osm/object.hpp>
+#include <osmium/util/string.hpp>
+
+#include <ostream>
+#include <stdexcept>
+#include <string>
+
+namespace osmium {
+
+    /**
+     * Describes which metadata fields are available in an OSMObject. This is most often used to
+     * describe which metadata fields are available in the objects of an OSM file or which
+     * metadata information should be written to an OSM file.
+     */
+    class metadata_options {
+
+        enum options : unsigned int {
+            md_none      = 0x00,
+            md_version   = 0x01,
+            md_timestamp = 0x02,
+            md_changeset = 0x04,
+            md_uid       = 0x08,
+            md_user      = 0x10,
+            md_all       = 0x1f
+        } m_options = md_all;
+
+    public:
+
+        metadata_options() noexcept = default;
+
+        explicit metadata_options(const std::string& attributes) {
+            if (attributes.empty() || attributes == "all" || attributes == "true" || attributes == "yes") {
+                return;
+            }
+            if (attributes == "none" || attributes == "false" || attributes == "no") {
+                m_options = options::md_none;
+                return;
+            }
+
+            const auto attrs = osmium::split_string(attributes, '+', true);
+            int opts = 0;
+            for (const auto& attr : attrs) {
+                if (attr == "version") {
+                    opts |= options::md_version;
+                } else if (attr == "timestamp") {
+                    opts |= options::md_timestamp;
+                } else if (attr == "changeset") {
+                    opts |= options::md_changeset;
+                } else if (attr == "uid") {
+                    opts |= options::md_uid;
+                } else if (attr == "user") {
+                    opts |= options::md_user;
+                } else {
+                    throw std::invalid_argument{std::string{"Unknown OSM object metadata attribute: '"} + attr + "'"};
+                }
+            }
+            m_options = static_cast<options>(opts);
+        }
+
+        /// At least one metadata attribute should be stored.
+        bool any() const noexcept {
+            return m_options != 0;
+        }
+
+        /// All metadata attributes should be stored.
+        bool all() const noexcept {
+            return m_options == options::md_all;
+        }
+
+        /// No metadata attributes should be stored.
+        bool none() const noexcept {
+            return m_options == 0;
+        }
+
+        bool version() const noexcept {
+            return (m_options & options::md_version) != 0;
+        }
+
+        void set_version(bool flag) noexcept {
+            if (flag) {
+                m_options = static_cast<options>(m_options | options::md_version);
+            } else {
+                m_options = static_cast<options>(m_options & ~options::md_version);
+            }
+        }
+
+        bool timestamp() const noexcept {
+            return (m_options & options::md_timestamp) != 0;
+        }
+
+        void set_timestamp(bool flag) noexcept {
+            if (flag) {
+                m_options = static_cast<options>(m_options | options::md_timestamp);
+            } else {
+                m_options = static_cast<options>(m_options & ~options::md_timestamp);
+            }
+        }
+
+        bool changeset() const noexcept {
+            return (m_options & options::md_changeset) != 0;
+        }
+
+        void set_changeset(bool flag) noexcept {
+            if (flag) {
+                m_options = static_cast<options>(m_options | options::md_changeset);
+            } else {
+                m_options = static_cast<options>(m_options & ~options::md_changeset);
+            }
+        }
+
+        bool uid() const noexcept {
+            return (m_options & options::md_uid) != 0;
+        }
+
+        void set_uid(bool flag) noexcept {
+            if (flag) {
+                m_options = static_cast<options>(m_options | options::md_uid);
+            } else {
+                m_options = static_cast<options>(m_options & ~options::md_uid);
+            }
+        }
+
+        bool user() const noexcept {
+            return (m_options & options::md_user) != 0;
+        }
+
+        void set_user(bool flag) noexcept {
+            if (flag) {
+                m_options = static_cast<options>(m_options | options::md_user);
+            } else {
+                m_options = static_cast<options>(m_options & ~options::md_user);
+            }
+        }
+
+        metadata_options operator&=(const metadata_options& other) {
+            m_options = static_cast<options>(other.m_options & m_options);
+            return *this;
+        }
+
+        metadata_options operator|=(const metadata_options& other) {
+            m_options = static_cast<options>(other.m_options | m_options);
+            return *this;
+        }
+
+        std::string to_string() const {
+            std::string result;
+
+            if (none()) {
+                result = "none";
+                return result;
+            }
+
+            if (all()) {
+                result = "all";
+                return result;
+            }
+
+            if (version()) {
+                result += "version+";
+            }
+
+            if (timestamp()) {
+                result += "timestamp+";
+            }
+
+            if (changeset()) {
+                result += "changeset+";
+            }
+
+            if (uid()) {
+                result += "uid+";
+            }
+
+            if (user()) {
+                 result += "user+";
+            }
+
+            // remove last '+' character
+            result.pop_back();
+
+            return result;
+        }
+
+    }; // class metadata_options
+
+    template <typename TChar, typename TTraits>
+    inline std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const metadata_options& options) {
+        return out << options.to_string();
+    }
+
+    /**
+     * Create an instance of metadata_options based on the availability of
+     * metadata of an instance of osmium::OSMObject.
+     */
+    inline osmium::metadata_options detect_available_metadata(const osmium::OSMObject& object) {
+        osmium::metadata_options opts;
+
+        opts.set_version(object.version() > 0);
+        opts.set_timestamp(object.timestamp().valid());
+        opts.set_changeset(object.changeset() > 0);
+
+        // Objects by anonymous users don't have these attributes set. There is no way
+        // to distinguish them from objects with a reduced number of metadata fields.
+        opts.set_uid(object.uid() > 0);
+        opts.set_user(object.user()[0] != '\0');
+
+        return opts;
+    }
+
+} // namespace osmium
+
+#endif // OSMIUM_OSM_METADATA_OPTIONS_HPP
diff --git a/third_party/libosmium/include/osmium/osm/node.hpp b/third_party/libosmium/include/osmium/osm/node.hpp
index 0e61bfb7062..40a223bba7f 100644
--- a/third_party/libosmium/include/osmium/osm/node.hpp
+++ b/third_party/libosmium/include/osmium/osm/node.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/node_ref.hpp b/third_party/libosmium/include/osmium/osm/node_ref.hpp
index c06f38f9a80..4c782ffd2bb 100644
--- a/third_party/libosmium/include/osmium/osm/node_ref.hpp
+++ b/third_party/libosmium/include/osmium/osm/node_ref.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <cstdlib>
-#include <iosfwd>
-
 #include <osmium/memory/item.hpp>
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/types.hpp>
 
+#include <cstdint>
+#include <cstdlib>
+#include <iosfwd>
+
 namespace osmium {
 
     /**
@@ -54,7 +54,13 @@ namespace osmium {
 
     public:
 
-        constexpr NodeRef(const osmium::object_id_type ref = 0, const osmium::Location& location = Location()) noexcept :
+        /**
+         * Constructor for NodeRef
+         *
+         * This is not explicit to allow implicit construction from an object
+         * ID.
+         */
+        constexpr NodeRef(const osmium::object_id_type ref = 0, const osmium::Location& location = Location{}) noexcept : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_ref(ref),
             m_location(location) {
         }
@@ -153,7 +159,7 @@ namespace osmium {
      * Node IDs.
      */
     inline constexpr bool operator!=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
-        return ! (lhs == rhs);
+        return !(lhs == rhs);
     }
 
     /**
@@ -177,7 +183,7 @@ namespace osmium {
      * they reference.
      */
     inline constexpr bool operator<=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
-        return ! (rhs < lhs);
+        return !(rhs < lhs);
     }
 
     /**
@@ -185,7 +191,7 @@ namespace osmium {
      * they reference.
      */
     inline constexpr bool operator>=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
-        return ! (lhs < rhs);
+        return !(lhs < rhs);
     }
 
     /**
diff --git a/third_party/libosmium/include/osmium/osm/node_ref_list.hpp b/third_party/libosmium/include/osmium/osm/node_ref_list.hpp
index 4411a2458f8..da84cc1aeef 100644
--- a/third_party/libosmium/include/osmium/osm/node_ref_list.hpp
+++ b/third_party/libosmium/include/osmium/osm/node_ref_list.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,16 +33,16 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cstddef>
-#include <iterator>
-
 #include <osmium/memory/item.hpp>
 #include <osmium/osm/box.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/node_ref.hpp>
 
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+
 namespace osmium {
 
     /**
@@ -137,7 +137,7 @@ namespace osmium {
          */
         const NodeRef& back() const noexcept {
             assert(!empty());
-            return operator[](size()-1);
+            return operator[](size() - 1);
         }
 
         /**
diff --git a/third_party/libosmium/include/osmium/osm/object.hpp b/third_party/libosmium/include/osmium/osm/object.hpp
index 1e477db1300..14cac072c1c 100644
--- a/third_party/libosmium/include/osmium/osm/object.hpp
+++ b/third_party/libosmium/include/osmium/osm/object.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdlib>
-#include <cstring>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
-
 #include <osmium/memory/collection.hpp>
 #include <osmium/memory/item.hpp>
 #include <osmium/memory/item_iterator.hpp>
@@ -51,6 +45,12 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types_from_string.hpp>
 #include <osmium/util/misc.hpp>
 
+#include <cstdlib>
+#include <cstring>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+
 namespace osmium {
 
     namespace builder {
@@ -66,12 +66,12 @@ namespace osmium {
         template <typename TDerived, typename T>
         friend class osmium::builder::OSMObjectBuilder;
 
-        object_id_type      m_id;
+        object_id_type      m_id = 0;
         bool                m_deleted : 1;
         object_version_type m_version : 31;
-        osmium::Timestamp   m_timestamp;
-        user_id_type        m_uid;
-        changeset_id_type   m_changeset;
+        osmium::Timestamp   m_timestamp{};
+        user_id_type        m_uid = 0;
+        changeset_id_type   m_changeset = 0;
 
         size_t sizeof_object() const noexcept {
             return sizeof(OSMObject) + (type() == item_type::node ? sizeof(osmium::Location) : 0) + sizeof(string_size_type);
@@ -101,12 +101,8 @@ namespace osmium {
 
         OSMObject(osmium::memory::item_size_type size, osmium::item_type type) :
             OSMEntity(size, type),
-            m_id(0),
             m_deleted(false),
-            m_version(0),
-            m_timestamp(),
-            m_uid(0),
-            m_changeset(0) {
+            m_version(0) {
         }
 
         void set_user_size(string_size_type size) {
@@ -278,7 +274,8 @@ namespace osmium {
          * @returns Reference to object to make calls chainable.
          */
         OSMObject& set_uid(const char* uid) {
-            return set_uid_from_signed(string_to_user_id(uid));
+            m_uid = string_to_uid(uid);
+            return *this;
         }
 
         /// Is this user anonymous?
@@ -460,7 +457,7 @@ namespace osmium {
     }
 
     inline bool operator!=(const OSMObject& lhs, const OSMObject& rhs) noexcept {
-        return ! (lhs == rhs);
+        return !(lhs == rhs);
     }
 
     /**
@@ -479,8 +476,10 @@ namespace osmium {
      * ordering.
      */
     inline bool operator<(const OSMObject& lhs, const OSMObject& rhs) noexcept {
-        return const_tie(lhs.type(), lhs.id() > 0, lhs.positive_id(), lhs.version(), lhs.timestamp()) <
-               const_tie(rhs.type(), rhs.id() > 0, rhs.positive_id(), rhs.version(), rhs.timestamp());
+        return const_tie(lhs.type(), lhs.id() > 0, lhs.positive_id(), lhs.version(),
+                   ((lhs.timestamp().valid() && rhs.timestamp().valid()) ? lhs.timestamp() : osmium::Timestamp())) <
+               const_tie(rhs.type(), rhs.id() > 0, rhs.positive_id(), rhs.version(),
+                   ((lhs.timestamp().valid() && rhs.timestamp().valid()) ? rhs.timestamp() : osmium::Timestamp()));
     }
 
     inline bool operator>(const OSMObject& lhs, const OSMObject& rhs) noexcept {
@@ -488,11 +487,11 @@ namespace osmium {
     }
 
     inline bool operator<=(const OSMObject& lhs, const OSMObject& rhs) noexcept {
-        return ! (rhs < lhs);
+        return !(rhs < lhs);
     }
 
     inline bool operator>=(const OSMObject& lhs, const OSMObject& rhs) noexcept {
-        return ! (lhs < rhs);
+        return !(lhs < rhs);
     }
 
 } // namespace osmium
diff --git a/third_party/libosmium/include/osmium/osm/object_comparisons.hpp b/third_party/libosmium/include/osmium/osm/object_comparisons.hpp
index a762f190f3e..2dce5d266be 100644
--- a/third_party/libosmium/include/osmium/osm/object_comparisons.hpp
+++ b/third_party/libosmium/include/osmium/osm/object_comparisons.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cassert>
-#include <cstdlib>
-#include <tuple>
-
 #include <osmium/osm/object.hpp>
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/util/misc.hpp>
 
+#include <cassert>
+#include <cstdlib>
+#include <tuple>
+
 namespace osmium {
 
     /**
@@ -111,6 +111,27 @@ namespace osmium {
 
     }; // struct object_order_type_id_version
 
+    /**
+     * Function object class for ordering OSM objects by type, id, and version.
+     *
+     * The naming is a bit awkward here, but necessary to keep backwards
+     * compatibility with object_order_type_id_version.
+     */
+    struct object_order_type_id_version_without_timestamp {
+
+        bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const noexcept {
+            return const_tie(lhs.type(), lhs.id() > 0, lhs.positive_id(), lhs.version()) <
+                   const_tie(rhs.type(), rhs.id() > 0, rhs.positive_id(), rhs.version());
+        }
+
+        /// @pre lhs and rhs must not be nullptr
+        bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const noexcept {
+            assert(lhs && rhs);
+            return operator()(*lhs, *rhs);
+        }
+
+    }; // struct object_order_type_id_version_without_timestamp
+
     /**
      * Function object class for ordering OSM objects by type, ID, and
      * reverse version, timestamp. So objects are ordered by type and ID
@@ -122,8 +143,10 @@ namespace osmium {
     struct object_order_type_id_reverse_version {
 
         bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const noexcept {
-            return const_tie(lhs.type(), lhs.id() > 0, lhs.positive_id(), rhs.version(), rhs.timestamp()) <
-                   const_tie(rhs.type(), rhs.id() > 0, rhs.positive_id(), lhs.version(), lhs.timestamp());
+            return const_tie(lhs.type(), lhs.id() > 0, lhs.positive_id(), rhs.version(),
+                        ((lhs.timestamp().valid() && rhs.timestamp().valid()) ? rhs.timestamp() : osmium::Timestamp())) <
+                   const_tie(rhs.type(), rhs.id() > 0, rhs.positive_id(), lhs.version(),
+                        ((lhs.timestamp().valid() && rhs.timestamp().valid()) ? lhs.timestamp() : osmium::Timestamp()));
         }
 
         /// @pre lhs and rhs must not be nullptr
diff --git a/third_party/libosmium/include/osmium/osm/relation.hpp b/third_party/libosmium/include/osmium/osm/relation.hpp
index 8122a1fc5d9..b9742e009c9 100644
--- a/third_party/libosmium/include/osmium/osm/relation.hpp
+++ b/third_party/libosmium/include/osmium/osm/relation.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,10 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstdint>
-#include <cstdlib>
-#include <iterator>
-
 #include <osmium/memory/collection.hpp> // IWYU pragma: keep
 #include <osmium/memory/item.hpp>
 #include <osmium/osm/entity.hpp>
@@ -45,6 +41,10 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/util/compatibility.hpp>
 
+#include <cstdint>
+#include <cstdlib>
+#include <iterator>
+
 namespace osmium {
 
     namespace builder {
@@ -63,12 +63,6 @@ namespace osmium {
         uint16_t         m_flags;
         string_size_type m_role_size = 0;
 
-        RelationMember(const RelationMember&) = delete;
-        RelationMember(RelationMember&&) = delete;
-
-        RelationMember& operator=(const RelationMember&) = delete;
-        RelationMember& operator=(RelationMember&&) = delete;
-
         unsigned char* endpos() {
             return data() + osmium::memory::padded_length(sizeof(RelationMember) + m_role_size);
         }
@@ -102,12 +96,20 @@ namespace osmium {
 
         static constexpr item_type collection_type = item_type::relation_member_list;
 
-        RelationMember(const object_id_type ref = 0, const item_type type = item_type(), const bool full = false) noexcept :
+        explicit RelationMember(const object_id_type ref = 0, const item_type type = item_type(), const bool full = false) noexcept :
             m_ref(ref),
             m_type(type),
             m_flags(full ? 1 : 0) {
         }
 
+        RelationMember(const RelationMember&) = delete;
+        RelationMember& operator=(const RelationMember&) = delete;
+
+        RelationMember(RelationMember&&) = delete;
+        RelationMember& operator=(RelationMember&&) = delete;
+
+        ~RelationMember() noexcept = default;
+
         object_id_type ref() const noexcept {
             return m_ref;
         }
@@ -158,9 +160,7 @@ namespace osmium {
                    t == osmium::item_type::relation_member_list_with_full_members;
         }
 
-        RelationMemberList() :
-            osmium::memory::Collection<RelationMember, osmium::item_type::relation_member_list>() {
-        }
+        RelationMemberList() noexcept = default;
 
     }; // class RelationMemberList
 
diff --git a/third_party/libosmium/include/osmium/osm/segment.hpp b/third_party/libosmium/include/osmium/osm/segment.hpp
index 8d66aae3ede..07c05f6b8b1 100644
--- a/third_party/libosmium/include/osmium/osm/segment.hpp
+++ b/third_party/libosmium/include/osmium/osm/segment.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/location.hpp>
+
 #include <iosfwd>
 #include <utility>
 
-#include <osmium/osm/location.hpp>
-
 namespace osmium {
 
     /**
@@ -55,14 +55,6 @@ namespace osmium {
             m_second(location2) {
         }
 
-        constexpr Segment(const Segment&) = default;
-        constexpr Segment(Segment&&) = default;
-
-        Segment& operator=(const Segment&) = default;
-        Segment& operator=(Segment&&) = default;
-
-        ~Segment() = default;
-
         /// Return first Location of Segment.
         constexpr osmium::Location first() const noexcept {
             return m_first;
@@ -88,7 +80,7 @@ namespace osmium {
     }
 
     inline constexpr bool operator!=(const Segment& lhs, const Segment& rhs) noexcept {
-        return ! (lhs == rhs);
+        return !(lhs == rhs);
     }
 
     /**
diff --git a/third_party/libosmium/include/osmium/osm/tag.hpp b/third_party/libosmium/include/osmium/osm/tag.hpp
index 3aaaf56e0f2..af4fc507b32 100644
--- a/third_party/libosmium/include/osmium/osm/tag.hpp
+++ b/third_party/libosmium/include/osmium/osm/tag.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,26 +33,20 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/collection.hpp>
+#include <osmium/memory/item.hpp>
+#include <osmium/osm/item_type.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <iosfwd>
 #include <iterator>
 
-#include <osmium/memory/collection.hpp>
-#include <osmium/memory/item.hpp>
-#include <osmium/osm/item_type.hpp>
-
 namespace osmium {
 
     class Tag : public osmium::memory::detail::ItemHelper {
 
-        Tag(const Tag&) = delete;
-        Tag(Tag&&) = delete;
-
-        Tag& operator=(const Tag&) = delete;
-        Tag& operator=(Tag&&) = delete;
-
         template <typename TMember>
         friend class osmium::memory::CollectionIterator;
 
@@ -74,6 +68,14 @@ namespace osmium {
 
     public:
 
+        Tag(const Tag&) = delete;
+        Tag& operator=(const Tag&) = delete;
+
+        Tag(Tag&&) = delete;
+        Tag& operator=(Tag&&) = delete;
+
+        ~Tag() noexcept = default;
+
         static constexpr item_type collection_type = item_type::tag_list;
 
         const char* key() const noexcept {
@@ -114,9 +116,7 @@ namespace osmium {
 
     public:
 
-        TagList() :
-            osmium::memory::Collection<Tag, osmium::item_type::tag_list>() {
-        }
+        TagList() noexcept = default;
 
         /**
          * Get tag value for the given tag key. If the key is not set, returns
diff --git a/third_party/libosmium/include/osmium/osm/timestamp.hpp b/third_party/libosmium/include/osmium/osm/timestamp.hpp
index b1c8edc39f6..54c0ae64d8e 100644
--- a/third_party/libosmium/include/osmium/osm/timestamp.hpp
+++ b/third_party/libosmium/include/osmium/osm/timestamp.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,9 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/compatibility.hpp>
+#include <osmium/util/minmax.hpp> // IWYU pragma: keep
+
 #include <cassert>
 #include <cstdint>
 #include <ctime>
@@ -42,13 +45,40 @@ DEALINGS IN THE SOFTWARE.
 #include <string>
 #include <type_traits>
 
-#include <osmium/util/compatibility.hpp>
-#include <osmium/util/minmax.hpp> // IWYU pragma: keep
-
 namespace osmium {
 
     namespace detail {
 
+        inline void add_2digit_int_to_string(int value, std::string& out) {
+            assert(value >= 0 && value <= 99);
+            if (value > 9) {
+                const int dec = value / 10;
+                out += static_cast<char>('0' + dec);
+                value -= dec * 10;
+            } else {
+                out += '0';
+            }
+            out += static_cast<char>('0' + value);
+        }
+
+        inline void add_4digit_int_to_string(int value, std::string& out) {
+            assert(value >= 1000 && value <= 9999);
+
+            const int dec1 = value / 1000;
+            out += static_cast<char>('0' + dec1);
+            value -= dec1 * 1000;
+
+            const int dec2 = value / 100;
+            out += static_cast<char>('0' + dec2);
+            value -= dec2 * 100;
+
+            const int dec3 = value / 10;
+            out += static_cast<char>('0' + dec3);
+            value -= dec3 * 10;
+
+            out += static_cast<char>('0' + value);
+        }
+
         inline time_t parse_timestamp(const char* str) {
             static const int mon_lengths[] = {
                 31, 29, 31, 30, 31, 30,
@@ -114,26 +144,14 @@ namespace osmium {
      */
     class Timestamp {
 
-        // length of ISO timestamp string yyyy-mm-ddThh:mm:ssZ\0
-        static constexpr const int timestamp_length = 20 + 1;
-
-        // The timestamp format for OSM timestamps in strftime(3) format.
-        // This is the ISO-Format "yyyy-mm-ddThh:mm:ssZ".
-        static const char* timestamp_format() {
-            static const char f[timestamp_length] = "%Y-%m-%dT%H:%M:%SZ";
-            return f;
-        }
-
-        uint32_t m_timestamp;
+        uint32_t m_timestamp = 0;
 
     public:
 
         /**
          * Default construct an invalid Timestamp.
          */
-        constexpr Timestamp() noexcept :
-            m_timestamp(0) {
-        }
+        constexpr Timestamp() noexcept = default;
 
         /**
          * Construct a Timestamp from any integer type containing the seconds
@@ -145,7 +163,7 @@ namespace osmium {
          * like @code node.set_timestamp(123); @endcode work.
          */
         template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
-        constexpr Timestamp(T timestamp) noexcept :
+        constexpr Timestamp(T timestamp) noexcept : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_timestamp(uint32_t(timestamp)) {
         }
 
@@ -202,7 +220,7 @@ namespace osmium {
          *
          * @deprecated You should call seconds_since_epoch() explicitly instead.
          */
-        OSMIUM_DEPRECATED constexpr operator time_t() const noexcept {
+        OSMIUM_DEPRECATED constexpr operator time_t() const noexcept { // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             return static_cast<time_t>(m_timestamp);
         }
 
@@ -230,21 +248,26 @@ namespace osmium {
 #ifndef NDEBUG
                 auto result =
 #endif
-#ifndef _MSC_VER
-                              gmtime_r(&sse, &tm);
+#ifndef _WIN32
+                gmtime_r(&sse, &tm);
                 assert(result != nullptr);
 #else
-                              gmtime_s(&tm, &sse);
+                gmtime_s(&tm, &sse);
                 assert(result == 0);
 #endif
 
-                s.resize(timestamp_length);
-                /* This const_cast is ok, because we know we have enough space
-                in the string for the format we are using (well at least until
-                the year will have 5 digits). And by setting the size
-                afterwards from the result of strftime we make sure thats set
-                right, too. */
-                s.resize(strftime(const_cast<char*>(s.c_str()), timestamp_length, timestamp_format(), &tm));
+                detail::add_4digit_int_to_string(tm.tm_year + 1900, s);
+                s += '-';
+                detail::add_2digit_int_to_string(tm.tm_mon + 1, s);
+                s += '-';
+                detail::add_2digit_int_to_string(tm.tm_mday, s);
+                s += 'T';
+                detail::add_2digit_int_to_string(tm.tm_hour, s);
+                s += ':';
+                detail::add_2digit_int_to_string(tm.tm_min, s);
+                s += ':';
+                detail::add_2digit_int_to_string(tm.tm_sec, s);
+                s += 'Z';
             }
 
             return s;
@@ -257,7 +280,7 @@ namespace osmium {
      * Timestamp.
      */
     inline constexpr Timestamp start_of_time() noexcept {
-        return Timestamp(1);
+        return {1};
     }
 
     /**
@@ -265,7 +288,7 @@ namespace osmium {
      * Timestamp.
      */
     inline constexpr Timestamp end_of_time() noexcept {
-        return Timestamp(std::numeric_limits<uint32_t>::max());
+        return {std::numeric_limits<uint32_t>::max()};
     }
 
     template <typename TChar, typename TTraits>
@@ -291,11 +314,11 @@ namespace osmium {
     }
 
     inline bool operator<=(const Timestamp& lhs, const Timestamp& rhs) noexcept {
-        return ! (rhs < lhs);
+        return !(rhs < lhs);
     }
 
     inline bool operator>=(const Timestamp& lhs, const Timestamp& rhs) noexcept {
-        return ! (lhs < rhs);
+        return !(lhs < rhs);
     }
 
     template <>
diff --git a/third_party/libosmium/include/osmium/osm/types.hpp b/third_party/libosmium/include/osmium/osm/types.hpp
index 8c7e48a12d3..fbd1dcf02e3 100644
--- a/third_party/libosmium/include/osmium/osm/types.hpp
+++ b/third_party/libosmium/include/osmium/osm/types.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/types_from_string.hpp b/third_party/libosmium/include/osmium/osm/types_from_string.hpp
index 43f6203a566..d1d9038aed6 100644
--- a/third_party/libosmium/include/osmium/osm/types_from_string.hpp
+++ b/third_party/libosmium/include/osmium/osm/types_from_string.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/entity_bits.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/util/compatibility.hpp>
+
 #include <cassert>
 #include <cctype>
 #include <cstdlib>
@@ -41,11 +46,6 @@ DEALINGS IN THE SOFTWARE.
 #include <string>
 #include <utility>
 
-#include <osmium/osm/entity_bits.hpp>
-#include <osmium/osm/item_type.hpp>
-#include <osmium/osm/types.hpp>
-#include <osmium/util/cast.hpp>
-
 namespace osmium {
 
     /**
@@ -62,8 +62,8 @@ namespace osmium {
         if (*input != '\0' && !std::isspace(*input)) {
             char* end;
             const auto id = std::strtoll(input, &end, 10);
-            if (id != std::numeric_limits<long long>::min() &&
-                id != std::numeric_limits<long long>::max() &&
+            if (id != std::numeric_limits<long long>::min() && // NOLINT(google-runtime-int)
+                id != std::numeric_limits<long long>::max() && // NOLINT(google-runtime-int)
                 *end == '\0') {
                 return id;
             }
@@ -107,12 +107,15 @@ namespace osmium {
 
     namespace detail {
 
-        inline unsigned long string_to_ulong(const char* input, const char* name) {
+        inline uint32_t string_to_ulong(const char* input, const char* name) {
+            if (input[0] == '-' && input[1] == '1' && input[2] == '\0') {
+                return 0;
+            }
             if (*input != '\0' && *input != '-' && !std::isspace(*input)) {
                 char* end;
                 const auto value = std::strtoul(input, &end, 10);
-                if (value != std::numeric_limits<unsigned long>::max() && *end == '\0') {
-                    return value;
+                if (value < std::numeric_limits<uint32_t>::max() && *end == '\0') {
+                    return static_cast<uint32_t>(value);
                 }
             }
             throw std::range_error{std::string{"illegal "} + name + ": '" + input + "'"};
@@ -131,7 +134,7 @@ namespace osmium {
      */
     inline object_version_type string_to_object_version(const char* input) {
         assert(input);
-        return static_cast_with_assert<object_version_type>(detail::string_to_ulong(input, "version"));
+        return detail::string_to_ulong(input, "version");
     }
 
     /**
@@ -145,7 +148,7 @@ namespace osmium {
      */
     inline changeset_id_type string_to_changeset_id(const char* input) {
         assert(input);
-        return static_cast_with_assert<changeset_id_type>(detail::string_to_ulong(input, "changeset"));
+        return detail::string_to_ulong(input, "changeset");
     }
 
     /**
@@ -156,13 +159,33 @@ namespace osmium {
      * @param input Input string.
      *
      * @throws std::range_error if the value is out of range.
+     *
+     * @deprecated Use string_to_uid() instead.
      */
-    inline signed_user_id_type string_to_user_id(const char* input) {
+    OSMIUM_DEPRECATED inline signed_user_id_type string_to_user_id(const char* input) {
         assert(input);
         if (input[0] == '-' && input[1] == '1' && input[2] == '\0') {
             return -1;
         }
-        return static_cast_with_assert<signed_user_id_type>(detail::string_to_ulong(input, "user id"));
+        const auto value = detail::string_to_ulong(input, "user id");
+        if (value > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
+            throw std::range_error{"illegal user id"};
+        }
+        return static_cast<signed_user_id_type>(value);
+    }
+
+    /**
+     * Convert string with user id to user_id_type.
+     *
+     * @pre input must not be nullptr.
+     *
+     * @param input Input string.
+     *
+     * @throws std::range_error if the value is out of range.
+     */
+    inline user_id_type string_to_uid(const char* input) {
+        assert(input);
+        return detail::string_to_ulong(input, "user id");
     }
 
     /**
@@ -176,7 +199,7 @@ namespace osmium {
      */
     inline num_changes_type string_to_num_changes(const char* input) {
         assert(input);
-        return static_cast_with_assert<num_changes_type>(detail::string_to_ulong(input, "value for num changes"));
+        return detail::string_to_ulong(input, "value for num changes");
     }
 
     /**
@@ -190,7 +213,7 @@ namespace osmium {
      */
     inline num_comments_type string_to_num_comments(const char* input) {
         assert(input);
-        return static_cast_with_assert<num_comments_type>(detail::string_to_ulong(input, "value for num comments"));
+        return detail::string_to_ulong(input, "value for num comments");
     }
 
 } // namespace osmium
diff --git a/third_party/libosmium/include/osmium/osm/undirected_segment.hpp b/third_party/libosmium/include/osmium/osm/undirected_segment.hpp
index 773b0d7b878..7a0eb4180aa 100644
--- a/third_party/libosmium/include/osmium/osm/undirected_segment.hpp
+++ b/third_party/libosmium/include/osmium/osm/undirected_segment.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <iosfwd>
-
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/segment.hpp>
 
+#include <iosfwd>
+
 namespace osmium {
 
     /**
@@ -56,14 +56,6 @@ namespace osmium {
             }
         }
 
-        UndirectedSegment(const UndirectedSegment&) = default;
-        UndirectedSegment(UndirectedSegment&&) = default;
-
-        UndirectedSegment& operator=(const UndirectedSegment&) = default;
-        UndirectedSegment& operator=(UndirectedSegment&&) = default;
-
-        ~UndirectedSegment() = default;
-
     }; // class UndirectedSegment
 
     /**
@@ -80,11 +72,11 @@ namespace osmium {
     }
 
     inline bool operator<=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) noexcept {
-        return ! (rhs < lhs);
+        return !(rhs < lhs);
     }
 
     inline bool operator>=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) noexcept {
-        return ! (lhs < rhs);
+        return !(lhs < rhs);
     }
 
     /**
diff --git a/third_party/libosmium/include/osmium/osm/way.hpp b/third_party/libosmium/include/osmium/osm/way.hpp
index 6b75b213b54..69bb5ad9e9a 100644
--- a/third_party/libosmium/include/osmium/osm/way.hpp
+++ b/third_party/libosmium/include/osmium/osm/way.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -62,7 +62,7 @@ namespace osmium {
             return t == itemtype;
         }
 
-        WayNodeList():
+        WayNodeList() noexcept :
             NodeRefList(itemtype) {
         }
 
diff --git a/third_party/libosmium/include/osmium/relations/collector.hpp b/third_party/libosmium/include/osmium/relations/collector.hpp
index ccfed99b120..63bfe3d747d 100644
--- a/third_party/libosmium/include/osmium/relations/collector.hpp
+++ b/third_party/libosmium/include/osmium/relations/collector.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,18 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/handler.hpp>
+#include <osmium/handler/check_order.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/relations/detail/member_meta.hpp>
+#include <osmium/relations/detail/relation_meta.hpp>
+#include <osmium/util/iterator.hpp>
+#include <osmium/visitor.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -43,19 +55,6 @@ DEALINGS IN THE SOFTWARE.
 #include <utility>
 #include <vector>
 
-#include <osmium/osm/item_type.hpp>
-#include <osmium/osm/object.hpp>
-#include <osmium/osm/relation.hpp>
-#include <osmium/osm/types.hpp>
-#include <osmium/handler.hpp>
-#include <osmium/handler/check_order.hpp>
-#include <osmium/memory/buffer.hpp>
-#include <osmium/util/iterator.hpp>
-#include <osmium/visitor.hpp>
-
-#include <osmium/relations/detail/relation_meta.hpp>
-#include <osmium/relations/detail/member_meta.hpp>
-
 namespace osmium {
 
     class Node;
@@ -137,7 +136,7 @@ namespace osmium {
                 void node(const osmium::Node& node) {
                     if (TNodes) {
                         m_check_order.node(node);
-                        if (! m_collector.find_and_add_object(node)) {
+                        if (!m_collector.find_and_add_object(node)) {
                             m_collector.node_not_in_any_relation(node);
                         }
                     }
@@ -146,7 +145,7 @@ namespace osmium {
                 void way(const osmium::Way& way) {
                     if (TWays) {
                         m_check_order.way(way);
-                        if (! m_collector.find_and_add_object(way)) {
+                        if (!m_collector.find_and_add_object(way)) {
                             m_collector.way_not_in_any_relation(way);
                         }
                     }
@@ -155,7 +154,7 @@ namespace osmium {
                 void relation(const osmium::Relation& relation) {
                     if (TRelations) {
                         m_check_order.relation(relation);
-                        if (! m_collector.find_and_add_object(relation)) {
+                        if (!m_collector.find_and_add_object(relation)) {
                             m_collector.relation_not_in_any_relation(relation);
                         }
                     }
@@ -208,9 +207,7 @@ namespace osmium {
             Collector() :
                 m_handler_pass2(*static_cast<TCollector*>(this)),
                 m_relations_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes),
-                m_members_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes),
-                m_relations(),
-                m_member_meta() {
+                m_members_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes) {
             }
 
         protected:
@@ -336,7 +333,7 @@ namespace osmium {
                 const size_t offset = m_relations_buffer.committed();
                 m_relations_buffer.add_item(relation);
 
-                RelationMeta relation_meta(offset);
+                RelationMeta relation_meta{offset};
 
                 int n = 0;
                 for (auto& member : m_relations_buffer.get<osmium::Relation>(offset).members()) {
@@ -354,7 +351,7 @@ namespace osmium {
                     m_relations_buffer.rollback();
                 } else {
                     m_relations_buffer.commit();
-                    m_relations.push_back(std::move(relation_meta));
+                    m_relations.push_back(relation_meta);
                 }
             }
 
@@ -411,7 +408,7 @@ namespace osmium {
                         const size_t relation_offset = member_meta.relation_pos();
                         static_cast<TCollector*>(this)->complete_relation(relation_meta);
                         clear_member_metas(relation_meta);
-                        m_relations[relation_offset] = RelationMeta();
+                        m_relations[relation_offset] = RelationMeta{};
                         possibly_purge_removed_members();
                     }
                 }
@@ -552,7 +549,9 @@ namespace osmium {
 
             template <typename TSource>
             void read_relations(TSource& source) {
-                read_relations(std::begin(source), std::end(source));
+                using std::begin;
+                using std::end;
+                read_relations(begin(source), end(source));
                 source.close();
             }
 
diff --git a/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp b/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp
index a1505563bca..54140b374ae 100644
--- a/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp
+++ b/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/types.hpp>
+
 #include <cstddef>
 #include <iosfwd>
 #include <limits>
 
-#include <osmium/osm/types.hpp>
-
 namespace osmium {
 
     namespace relations {
diff --git a/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp b/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp
index 03476a55e1c..221050adf3f 100644
--- a/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp
+++ b/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -51,7 +51,7 @@ namespace osmium {
         class RelationMeta {
 
             /// The relation we are assembling.
-            size_t m_relation_offset;
+            size_t m_relation_offset = 0;
 
             /**
              * The number of members still needed before the relation is
@@ -67,9 +67,7 @@ namespace osmium {
              * Initialize an empty RelationMeta. This is needed to zero out
              * relations that have been completed.
              */
-            RelationMeta() noexcept :
-                m_relation_offset(0) {
-            }
+            RelationMeta() noexcept = default;
 
             explicit RelationMeta(size_t relation_offset) noexcept :
                 m_relation_offset(relation_offset) {
diff --git a/third_party/libosmium/include/osmium/relations/manager_util.hpp b/third_party/libosmium/include/osmium/relations/manager_util.hpp
index 1ee8dd48259..3248b488ca8 100644
--- a/third_party/libosmium/include/osmium/relations/manager_util.hpp
+++ b/third_party/libosmium/include/osmium/relations/manager_util.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <cstddef>
-#include <initializer_list>
-#include <iomanip>
-#include <utility>
-
 #include <osmium/fwd.hpp>
 #include <osmium/handler.hpp>
 #include <osmium/handler/check_order.hpp>
@@ -48,6 +43,11 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/util/progress_bar.hpp>
 #include <osmium/visitor.hpp>
 
+#include <cstddef>
+#include <initializer_list>
+#include <iomanip>
+#include <utility>
+
 namespace osmium {
 
     namespace relations {
@@ -174,7 +174,7 @@ namespace osmium {
          * stream.
          *
          * @tparam TStream Output stream type (like std::cout, std::cerr, or
-         *                 osmium::util::VerboseOutput).
+         *                 osmium::VerboseOutput).
          * @param stream Reference to stream where the output should go.
          * @param mu Memory usage data as returned by the used_memory()
          *                  functions of various relations managers.
diff --git a/third_party/libosmium/include/osmium/relations/members_database.hpp b/third_party/libosmium/include/osmium/relations/members_database.hpp
index 975f0038891..b66d3b38876 100644
--- a/third_party/libosmium/include/osmium/relations/members_database.hpp
+++ b/third_party/libosmium/include/osmium/relations/members_database.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,13 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/relations/relations_database.hpp>
+#include <osmium/storage/item_stash.hpp>
+#include <osmium/util/iterator.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -41,13 +48,6 @@ DEALINGS IN THE SOFTWARE.
 #include <type_traits>
 #include <vector>
 
-#include <osmium/osm/object.hpp>
-#include <osmium/osm/relation.hpp>
-#include <osmium/osm/types.hpp>
-#include <osmium/relations/relations_database.hpp>
-#include <osmium/storage/item_stash.hpp>
-#include <osmium/util/iterator.hpp>
-
 namespace osmium {
 
     namespace relations {
@@ -133,7 +133,7 @@ namespace osmium {
                 }
             };
 
-            std::vector<element> m_elements;
+            std::vector<element> m_elements{};
 
         protected:
 
@@ -171,7 +171,6 @@ namespace osmium {
             }
 
             MembersDatabaseCommon(osmium::ItemStash& stash, osmium::relations::RelationsDatabase& relations_db) :
-                m_elements(),
                 m_stash(stash),
                 m_relations_db(relations_db) {
             }
diff --git a/third_party/libosmium/include/osmium/relations/relations_database.hpp b/third_party/libosmium/include/osmium/relations/relations_database.hpp
index 80dd10242ed..fbe114cc0f4 100644
--- a/third_party/libosmium/include/osmium/relations/relations_database.hpp
+++ b/third_party/libosmium/include/osmium/relations/relations_database.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/relation.hpp>
+#include <osmium/storage/item_stash.hpp>
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <utility>
 #include <vector>
 
-#include <osmium/osm/relation.hpp>
-#include <osmium/storage/item_stash.hpp>
-
 namespace osmium {
 
     namespace relations {
diff --git a/third_party/libosmium/include/osmium/relations/relations_manager.hpp b/third_party/libosmium/include/osmium/relations/relations_manager.hpp
index 1831cb6c983..93ba510e2ed 100644
--- a/third_party/libosmium/include/osmium/relations/relations_manager.hpp
+++ b/third_party/libosmium/include/osmium/relations/relations_manager.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <stdexcept>
-#include <type_traits>
-#include <vector>
-
 #include <osmium/handler.hpp>
 #include <osmium/handler/check_order.hpp>
 #include <osmium/memory/buffer.hpp>
@@ -57,6 +48,15 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/tags/taglist.hpp>
 #include <osmium/tags/tags_filter.hpp>
 
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
 namespace osmium {
 
     namespace relations {
@@ -75,7 +75,7 @@ namespace osmium {
 
             // All relations and members we are interested in will be kept
             // in here.
-            osmium::ItemStash m_stash;
+            osmium::ItemStash m_stash{};
 
             /// Database of all relations we are interested in.
             relations::RelationsDatabase m_relations_db;
@@ -86,17 +86,15 @@ namespace osmium {
             relations::MembersDatabase<osmium::Relation> m_member_relations_db;
 
             /// Output buffer.
-            osmium::memory::CallbackBuffer m_output;
+            osmium::memory::CallbackBuffer m_output{};
 
         public:
 
             RelationsManagerBase() :
-                m_stash(),
                 m_relations_db(m_stash),
                 m_member_nodes_db(m_stash, m_relations_db),
                 m_member_ways_db(m_stash, m_relations_db),
-                m_member_relations_db(m_stash, m_relations_db),
-                m_output() {
+                m_member_relations_db(m_stash, m_relations_db) {
             }
 
             /// Access the internal RelationsDatabase.
@@ -507,7 +505,7 @@ namespace osmium {
                     const bool added = member_nodes_database().add(node, [this](RelationHandle& rel_handle) {
                         handle_complete_relation(rel_handle);
                     });
-                    if (! added) {
+                    if (!added) {
                         derived().node_not_in_any_relation(node);
                     }
                     derived().after_node(node);
@@ -522,7 +520,7 @@ namespace osmium {
                     const bool added = member_ways_database().add(way, [this](RelationHandle& rel_handle) {
                         handle_complete_relation(rel_handle);
                     });
-                    if (! added) {
+                    if (!added) {
                         derived().way_not_in_any_relation(way);
                     }
                     derived().after_way(way);
@@ -537,7 +535,7 @@ namespace osmium {
                     const bool added = member_relations_database().add(relation, [this](RelationHandle& rel_handle) {
                         handle_complete_relation(rel_handle);
                     });
-                    if (! added) {
+                    if (!added) {
                         derived().relation_not_in_any_relation(relation);
                     }
                     derived().after_relation(relation);
diff --git a/third_party/libosmium/include/osmium/storage/item_stash.hpp b/third_party/libosmium/include/osmium/storage/item_stash.hpp
index b49d88bcbd3..566fe0365cf 100644
--- a/third_party/libosmium/include/osmium/storage/item_stash.hpp
+++ b/third_party/libosmium/include/osmium/storage/item_stash.hpp
@@ -1,11 +1,11 @@
-#ifndef OSMIUM_ITEM_STASH_HPP
-#define OSMIUM_ITEM_STASH_HPP
+#ifndef OSMIUM_STORAGE_ITEM_STASH_HPP
+#define OSMIUM_STORAGE_ITEM_STASH_HPP
 
 /*
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,9 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/item.hpp>
+
 #include <cassert>
 #include <cstdlib>
 #include <limits>
@@ -44,9 +47,6 @@ DEALINGS IN THE SOFTWARE.
 # include <chrono>
 #endif
 
-#include <osmium/memory/buffer.hpp>
-#include <osmium/memory/item.hpp>
-
 namespace osmium {
 
     /**
@@ -72,7 +72,12 @@ namespace osmium {
 
             friend class ItemStash;
 
-            std::size_t value;
+            std::size_t value; // NOLINT(modernize-use-default-member-init)
+                               // Some compilers don't like the default member
+                               // init: "error: defaulted default constructor
+                               // of 'handle_type' cannot be used by non-static
+                               // data member initializer which appears before
+                               // end of class definition"
 
             explicit handle_type(std::size_t new_value) noexcept :
                 value(new_value) {
@@ -81,7 +86,7 @@ namespace osmium {
 
         public:
 
-            /// The defalt constructor creates an invalid handle.
+            /// The default constructor creates an invalid handle.
             handle_type() noexcept :
                 value(0) {
             }
@@ -339,4 +344,4 @@ namespace osmium {
 
 } // namespace osmium
 
-#endif // OSMIUM_ITEM_STASH_HPP
+#endif // OSMIUM_STORAGE_ITEM_STASH_HPP
diff --git a/third_party/libosmium/include/osmium/tags/filter.hpp b/third_party/libosmium/include/osmium/tags/filter.hpp
index 89c6f1102c4..4516edf78a0 100644
--- a/third_party/libosmium/include/osmium/tags/filter.hpp
+++ b/third_party/libosmium/include/osmium/tags/filter.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,17 +33,17 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/memory/collection.hpp>
+#include <osmium/osm/tag.hpp>
+
+#include <boost/iterator/filter_iterator.hpp>
+
 #include <cstddef>
 #include <cstring>
 #include <string>
 #include <type_traits>
 #include <vector>
 
-#include <boost/iterator/filter_iterator.hpp>
-
-#include <osmium/memory/collection.hpp>
-#include <osmium/osm/tag.hpp>
-
 namespace osmium {
 
     namespace tags {
@@ -84,13 +84,13 @@ namespace osmium {
 
         template <>
         struct match_value<void> {
-            bool operator()(const bool, const char*) const noexcept {
+            bool operator()(const bool /*rule_value*/, const char* /*tag_value*/) const noexcept {
                 return true;
             }
         }; // struct match_value<void>
 
         /// @deprecated Use osmium::TagsFilter instead.
-        template <typename TKey, typename TValue=void, typename TKeyComp=match_key<TKey>, typename TValueComp=match_value<TValue>>
+        template <typename TKey, typename TValue = void, typename TKeyComp = match_key<TKey>, typename TValueComp = match_value<TValue>>
         class Filter {
 
             using key_type   = TKey;
@@ -102,15 +102,15 @@ namespace osmium {
                 bool ignore_value;
                 bool result;
 
-                explicit Rule(bool r, bool ignore, const key_type& k, const value_type& v) :
-                    key(k),
-                    value(v),
+                explicit Rule(bool r, bool ignore, key_type k, value_type v) :
+                    key(std::move(k)),
+                    value(std::move(v)),
                     ignore_value(ignore),
                     result(r) {
                 }
 
-                explicit Rule(bool r, bool ignore, const key_type& k) :
-                    key(k),
+                explicit Rule(bool r, bool ignore, key_type k) :
+                    key(std::move(k)),
                     value(),
                     ignore_value(ignore),
                     result(r) {
@@ -132,7 +132,7 @@ namespace osmium {
                 m_default_result(default_result) {
             }
 
-            template <typename V=TValue, typename std::enable_if<!std::is_void<V>::value, int>::type = 0>
+            template <typename V = TValue, typename std::enable_if<!std::is_void<V>::value, int>::type = 0>
             Filter& add(bool result, const key_type& key, const value_type& value) {
                 m_rules.emplace_back(result, false, key, value);
                 return *this;
diff --git a/third_party/libosmium/include/osmium/tags/matcher.hpp b/third_party/libosmium/include/osmium/tags/matcher.hpp
index 4b1978b2da7..bceac3b5b03 100644
--- a/third_party/libosmium/include/osmium/tags/matcher.hpp
+++ b/third_party/libosmium/include/osmium/tags/matcher.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <type_traits>
-#include <utility>
-
 #include <osmium/osm/tag.hpp>
 #include <osmium/util/string_matcher.hpp>
 
+#include <type_traits>
+#include <utility>
+
 namespace osmium {
 
     /**
@@ -48,7 +48,7 @@ namespace osmium {
 
         osmium::StringMatcher m_key_matcher;
         osmium::StringMatcher m_value_matcher;
-        bool m_result;
+        bool m_result = true;
 
     public:
 
@@ -57,8 +57,7 @@ namespace osmium {
          */
         TagMatcher() :
             m_key_matcher(osmium::StringMatcher::always_false{}),
-            m_value_matcher(osmium::StringMatcher::always_false{}),
-            m_result(true) {
+            m_value_matcher(osmium::StringMatcher::always_false{}) {
         }
 
         /**
@@ -69,10 +68,9 @@ namespace osmium {
          */
         template <typename TKey, typename std::enable_if<
             std::is_convertible<TKey, osmium::StringMatcher>::value, int>::type = 0>
-        TagMatcher(TKey&& key_matcher) :
+        explicit TagMatcher(TKey&& key_matcher) : // NOLINT(misc-forwarding-reference-overload) (false positive due to enable_if)
             m_key_matcher(std::forward<TKey>(key_matcher)),
-            m_value_matcher(osmium::StringMatcher::always_true{}),
-            m_result(true) {
+            m_value_matcher(osmium::StringMatcher::always_true{}) {
         }
 
         /**
diff --git a/third_party/libosmium/include/osmium/tags/regex_filter.hpp b/third_party/libosmium/include/osmium/tags/regex_filter.hpp
index 98ed94d80fe..3b895a06e27 100644
--- a/third_party/libosmium/include/osmium/tags/regex_filter.hpp
+++ b/third_party/libosmium/include/osmium/tags/regex_filter.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/tags/filter.hpp>
+
 #include <regex>
 #include <string>
 
-#include <osmium/tags/filter.hpp>
-
 namespace osmium {
 
     namespace tags {
diff --git a/third_party/libosmium/include/osmium/tags/taglist.hpp b/third_party/libosmium/include/osmium/tags/taglist.hpp
index 3f640d6b213..2c2be14e238 100644
--- a/third_party/libosmium/include/osmium/tags/taglist.hpp
+++ b/third_party/libosmium/include/osmium/tags/taglist.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,12 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/osm/tag.hpp>
+
 #include <algorithm>
 #include <functional>
 #include <utility> // IWYU pragma: keep
 
-#include <osmium/osm/tag.hpp>
-
 namespace osmium {
 
     /**
diff --git a/third_party/libosmium/include/osmium/tags/tags_filter.hpp b/third_party/libosmium/include/osmium/tags/tags_filter.hpp
index 85d763e435e..85a7971b864 100644
--- a/third_party/libosmium/include/osmium/tags/tags_filter.hpp
+++ b/third_party/libosmium/include/osmium/tags/tags_filter.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,14 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <utility>
-#include <vector>
-
 #include <osmium/osm/tag.hpp>
 #include <osmium/tags/matcher.hpp>
 
 #include <boost/iterator/filter_iterator.hpp>
 
+#include <utility>
+#include <vector>
+
 namespace osmium {
 
     /**
diff --git a/third_party/libosmium/include/osmium/thread/function_wrapper.hpp b/third_party/libosmium/include/osmium/thread/function_wrapper.hpp
index ed68d8f8afe..7e1abdb6784 100644
--- a/third_party/libosmium/include/osmium/thread/function_wrapper.hpp
+++ b/third_party/libosmium/include/osmium/thread/function_wrapper.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -49,7 +49,16 @@ namespace osmium {
 
             struct impl_base {
 
-                virtual ~impl_base() = default;
+                impl_base() noexcept = default;
+
+                impl_base(const impl_base&) noexcept = default;
+                impl_base& operator=(const impl_base&) noexcept = default;
+
+                impl_base(impl_base&&) noexcept = default;
+                impl_base& operator=(impl_base&&) noexcept = default;
+
+                virtual ~impl_base() noexcept = default;
+
                 virtual bool call() {
                     return true;
                 }
@@ -80,14 +89,14 @@ namespace osmium {
             // to work seemlessly.
             template <typename TFunction>
             // cppcheck-suppress noExplicitConstructor
-            function_wrapper(TFunction&& f) :
+            function_wrapper(TFunction&& f) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions, misc-forwarding-reference-overload)
                 impl(new impl_type<TFunction>(std::forward<TFunction>(f))) {
             }
 
             // The integer parameter is only used to signal that we want
             // the special function wrapper that makes the worker thread
             // shut down.
-            explicit function_wrapper(int) :
+            explicit function_wrapper(int /*dummy*/) :
                 impl(new impl_base()) {
             }
 
@@ -97,18 +106,18 @@ namespace osmium {
 
             function_wrapper() = default;
 
-            function_wrapper(function_wrapper&& other) :
+            function_wrapper(const function_wrapper&) = delete;
+            function_wrapper& operator=(const function_wrapper&) = delete;
+
+            function_wrapper(function_wrapper&& other) noexcept :
                 impl(std::move(other.impl)) {
             }
 
-            function_wrapper& operator=(function_wrapper&& other) {
+            function_wrapper& operator=(function_wrapper&& other) noexcept {
                 impl = std::move(other.impl);
                 return *this;
             }
 
-            function_wrapper(const function_wrapper&) = delete;
-            function_wrapper& operator=(const function_wrapper&) = delete;
-
             ~function_wrapper() = default;
 
             explicit operator bool() const {
diff --git a/third_party/libosmium/include/osmium/thread/pool.hpp b/third_party/libosmium/include/osmium/thread/pool.hpp
index ef64954cbe1..03c6c94c435 100644
--- a/third_party/libosmium/include/osmium/thread/pool.hpp
+++ b/third_party/libosmium/include/osmium/thread/pool.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/thread/function_wrapper.hpp>
+#include <osmium/thread/queue.hpp>
+#include <osmium/thread/util.hpp>
+#include <osmium/util/config.hpp>
+
 #include <cstddef>
 #include <future>
 #include <thread>
@@ -40,11 +45,6 @@ DEALINGS IN THE SOFTWARE.
 #include <utility>
 #include <vector>
 
-#include <osmium/thread/function_wrapper.hpp>
-#include <osmium/thread/queue.hpp>
-#include <osmium/thread/util.hpp>
-#include <osmium/util/config.hpp>
-
 namespace osmium {
 
     /**
@@ -102,6 +102,12 @@ namespace osmium {
                     m_threads(threads) {
                 }
 
+                thread_joiner(const thread_joiner&) = delete;
+                thread_joiner& operator=(const thread_joiner&) = delete;
+
+                thread_joiner(thread_joiner&&) = delete;
+                thread_joiner& operator=(thread_joiner&&) = delete;
+
                 ~thread_joiner() {
                     for (auto& thread : m_threads) {
                         if (thread.joinable()) {
@@ -113,7 +119,7 @@ namespace osmium {
             }; // class thread_joiner
 
             osmium::thread::Queue<function_wrapper> m_work_queue;
-            std::vector<std::thread> m_threads;
+            std::vector<std::thread> m_threads{};
             thread_joiner m_joiner;
             int m_num_threads;
 
@@ -152,13 +158,12 @@ namespace osmium {
              */
             explicit Pool(int num_threads = default_num_threads, std::size_t max_queue_size = default_queue_size) :
                 m_work_queue(max_queue_size > 0 ? max_queue_size : detail::get_work_queue_size(), "work"),
-                m_threads(),
                 m_joiner(m_threads),
                 m_num_threads(detail::get_pool_size(num_threads, osmium::config::get_pool_threads(), std::thread::hardware_concurrency())) {
 
                 try {
                     for (int i = 0; i < m_num_threads; ++i) {
-                        m_threads.push_back(std::thread(&Pool::worker_thread, this));
+                        m_threads.emplace_back(&Pool::worker_thread, this);
                     }
                 } catch (...) {
                     shutdown_all_workers();
@@ -178,6 +183,12 @@ namespace osmium {
                 }
             }
 
+            Pool(const Pool&) = delete;
+            Pool& operator=(const Pool&) = delete;
+
+            Pool(Pool&&) = delete;
+            Pool& operator=(Pool&&) = delete;
+
             ~Pool() {
                 shutdown_all_workers();
             }
diff --git a/third_party/libosmium/include/osmium/thread/queue.hpp b/third_party/libosmium/include/osmium/thread/queue.hpp
index 39df6857cb7..d34bfaa069b 100644
--- a/third_party/libosmium/include/osmium/thread/queue.hpp
+++ b/third_party/libosmium/include/osmium/thread/queue.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -50,8 +50,6 @@ namespace osmium {
 
     namespace thread {
 
-        static const std::chrono::milliseconds max_wait{10};
-
         /**
          *  A thread-safe queue.
          */
@@ -106,13 +104,10 @@ namespace osmium {
              *                 0 for an unlimited size.
              * @param name Optional name for this queue. (Used for debugging.)
              */
-            explicit Queue(std::size_t max_size = 0, const std::string& name = "") :
+            explicit Queue(std::size_t max_size = 0, std::string name = "") :
                 m_max_size(max_size),
-                m_name(name),
-                m_mutex(),
-                m_queue(),
-                m_data_available(),
-                m_space_available()
+                m_name(std::move(name)),
+                m_queue()
 #ifdef OSMIUM_DEBUG_QUEUE_SIZE
                 ,
                 m_largest_size(0),
@@ -124,8 +119,14 @@ namespace osmium {
             {
             }
 
-            ~Queue() {
+            Queue(const Queue&) = delete;
+            Queue& operator=(const Queue&) = delete;
+
+            Queue(Queue&&) = delete;
+            Queue& operator=(Queue&&) = delete;
+
 #ifdef OSMIUM_DEBUG_QUEUE_SIZE
+            ~Queue() {
                 std::cerr << "queue '" << m_name
                           << "' with max_size=" << m_max_size
                           << " had largest size " << m_largest_size
@@ -134,14 +135,17 @@ namespace osmium {
                           << " push() calls and was empty " << m_empty_counter
                           << " times in " << m_pop_counter
                           << " pop() calls\n";
-#endif
             }
+#else
+            ~Queue() = default;
+#endif
 
             /**
              * Push an element onto the queue. If the queue has a max size,
              * this call will block if the queue is full.
              */
             void push(T value) {
+                constexpr const std::chrono::milliseconds max_wait{10};
 #ifdef OSMIUM_DEBUG_QUEUE_SIZE
                 ++m_push_counter;
 #endif
diff --git a/third_party/libosmium/include/osmium/thread/util.hpp b/third_party/libosmium/include/osmium/thread/util.hpp
index 53d16a19ea3..418f9fe9a75 100644
--- a/third_party/libosmium/include/osmium/thread/util.hpp
+++ b/third_party/libosmium/include/osmium/thread/util.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -88,9 +88,7 @@ namespace osmium {
 
         public:
 
-            thread_handler() :
-                m_thread() {
-            }
+            thread_handler() = default;
 
             template <typename TFunction, typename... TArgs>
             explicit thread_handler(TFunction&& f, TArgs&&... args) :
@@ -100,8 +98,8 @@ namespace osmium {
             thread_handler(const thread_handler&) = delete;
             thread_handler& operator=(const thread_handler&) = delete;
 
-            thread_handler(thread_handler&&) = default;
-            thread_handler& operator=(thread_handler&&) = default;
+            thread_handler(thread_handler&&) noexcept = default;
+            thread_handler& operator=(thread_handler&&) noexcept = default;
 
             ~thread_handler() {
                 if (m_thread.joinable()) {
diff --git a/third_party/libosmium/include/osmium/util/cast.hpp b/third_party/libosmium/include/osmium/util/cast.hpp
index 76c10b27218..fd03e41f3d9 100644
--- a/third_party/libosmium/include/osmium/util/cast.hpp
+++ b/third_party/libosmium/include/osmium/util/cast.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/compatibility.hpp b/third_party/libosmium/include/osmium/util/compatibility.hpp
index f891173cbdd..3686a359de6 100644
--- a/third_party/libosmium/include/osmium/util/compatibility.hpp
+++ b/third_party/libosmium/include/osmium/util/compatibility.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/config.hpp b/third_party/libosmium/include/osmium/util/config.hpp
index f9cc96cfc56..76e12524337 100644
--- a/third_party/libosmium/include/osmium/util/config.hpp
+++ b/third_party/libosmium/include/osmium/util/config.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/misc.hpp>
+
 #include <cassert>
 #include <cstddef>
 #include <cstdlib>
@@ -45,18 +47,28 @@ DEALINGS IN THE SOFTWARE.
 
 namespace osmium {
 
+    namespace detail {
+
+#ifndef OSMIUM_TEST_RUNNER
+        inline const char* getenv_wrapper(const char* var) noexcept {
+            return getenv(var);
+        }
+#endif
+
+    } // namespace detail
+
     namespace config {
 
         inline int get_pool_threads() noexcept {
-            const char* env = getenv("OSMIUM_POOL_THREADS");
+            auto env = osmium::detail::getenv_wrapper("OSMIUM_POOL_THREADS");
             if (env) {
-                return std::atoi(env);
+                return osmium::detail::str_to_int<int>(env);
             }
             return 0;
         }
 
         inline bool use_pool_threads_for_pbf_parsing() noexcept {
-            const char* env = getenv("OSMIUM_USE_POOL_THREADS_FOR_PBF_PARSING");
+            auto env = osmium::detail::getenv_wrapper("OSMIUM_USE_POOL_THREADS_FOR_PBF_PARSING");
             if (env) {
                 if (!strcasecmp(env, "off") ||
                     !strcasecmp(env, "false") ||
@@ -73,9 +85,9 @@ namespace osmium {
             std::string name{"OSMIUM_MAX_"};
             name += queue_name;
             name += "_QUEUE_SIZE";
-            const char* env = getenv(name.c_str());
+            auto env = osmium::detail::getenv_wrapper(name.c_str());
             if (env) {
-                auto value = std::atoi(env);
+                const auto value = osmium::detail::str_to_int<std::size_t>(env);
                 return value == 0 ? default_value : value;
             }
             return default_value;
diff --git a/third_party/libosmium/include/osmium/util/delta.hpp b/third_party/libosmium/include/osmium/util/delta.hpp
index ec0ddd66fb3..59e4c809118 100644
--- a/third_party/libosmium/include/osmium/util/delta.hpp
+++ b/third_party/libosmium/include/osmium/util/delta.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/cast.hpp>
+
 #include <cstdint>
 #include <type_traits>
 #include <utility>
 
-#include <osmium/util/cast.hpp>
-
 namespace osmium {
 
-    namespace util {
+    inline namespace util {
 
         /**
          * Helper class for delta encoding.
@@ -111,8 +111,12 @@ namespace osmium {
             }
 
             TValue update(TDelta delta) noexcept {
-                m_value = static_cast_with_assert<TValue>(
-                              static_cast_with_assert<TDelta>(m_value) + delta);
+                // Do not check for overflow. With real data this should not
+                // happen and if somebody is trying to trick us they can only
+                // create values this way they would also be able to generate
+                // without having an overflow.
+                m_value = static_cast<TValue>(
+                              static_cast<TDelta>(m_value) + delta);
                 return m_value;
             }
 
diff --git a/third_party/libosmium/include/osmium/util/double.hpp b/third_party/libosmium/include/osmium/util/double.hpp
index 837faab759d..7b9c1e5c1a5 100644
--- a/third_party/libosmium/include/osmium/util/double.hpp
+++ b/third_party/libosmium/include/osmium/util/double.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -41,7 +41,7 @@ DEALINGS IN THE SOFTWARE.
 
 namespace osmium {
 
-    namespace util {
+    inline namespace util {
 
         constexpr const int max_double_length = 20; // should fit any double
 
diff --git a/third_party/libosmium/include/osmium/util/endian.hpp b/third_party/libosmium/include/osmium/util/endian.hpp
index 3ca2c2f4f55..2db8746292f 100644
--- a/third_party/libosmium/include/osmium/util/endian.hpp
+++ b/third_party/libosmium/include/osmium/util/endian.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,8 +34,8 @@ DEALINGS IN THE SOFTWARE.
 */
 
 // Windows is only available for little endian architectures
-// http://stackoverflow.com/questions/6449468/can-i-safely-assume-that-windows-installations-will-always-be-little-endian
-#if defined(__FreeBSD__)
+// https://stackoverflow.com/questions/6449468/can-i-safely-assume-that-windows-installations-will-always-be-little-endian
+#if defined(__FreeBSD__) || defined(__DragonFly__)
 # include <sys/endian.h>
 #elif !defined(_WIN32) && !defined(__APPLE__)
 # include <endian.h>
diff --git a/third_party/libosmium/include/osmium/util/file.hpp b/third_party/libosmium/include/osmium/util/file.hpp
index 4af6d77ebe2..34c26031b67 100644
--- a/third_party/libosmium/include/osmium/util/file.hpp
+++ b/third_party/libosmium/include/osmium/util/file.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,71 +33,71 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/cast.hpp>
+
 #include <cerrno>
 #include <cstddef>
 #include <cstdio>
 #include <string>
-#include <system_error>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <system_error>
 
 #ifdef _WIN32
 #  ifndef WIN32_LEAN_AND_MEAN
 #   define WIN32_LEAN_AND_MEAN // Prevent winsock.h inclusion; avoid winsock2.h conflict
 #  endif
+# include <crtdbg.h>
 # include <io.h>
 # include <windows.h>
-# include <crtdbg.h>
 #endif
 
 #ifndef _MSC_VER
 # include <unistd.h>
 #endif
 
-#include <osmium/util/cast.hpp>
-
 namespace osmium {
 
-    namespace util {
-
 #ifdef _MSC_VER
-        namespace detail {
-
-            // Disable parameter validation on Windows and reenable it
-            // automatically when scope closes.
-            // https://docs.microsoft.com/en-us/cpp/c-runtime-library/parameter-validation
-            class disable_invalid_parameter_handler {
-
-                static void invalid_parameter_handler(
-                        const wchar_t* expression,
-                        const wchar_t* function,
-                        const wchar_t* file,
-                        unsigned int line,
-                        uintptr_t pReserved
-                        ) {
-                    // do nothing
-                }
+    namespace detail {
+
+        // Disable parameter validation on Windows and reenable it
+        // automatically when scope closes.
+        // https://docs.microsoft.com/en-us/cpp/c-runtime-library/parameter-validation
+        class disable_invalid_parameter_handler {
+
+            static void invalid_parameter_handler(
+                    const wchar_t* expression,
+                    const wchar_t* function,
+                    const wchar_t* file,
+                    unsigned int line,
+                    uintptr_t pReserved
+                    ) {
+                // do nothing
+            }
 
-                _invalid_parameter_handler old_handler;
-                int old_report_mode;
+            _invalid_parameter_handler old_handler;
+            int old_report_mode;
 
-            public:
+        public:
 
-                disable_invalid_parameter_handler() :
-                    old_handler(_set_thread_local_invalid_parameter_handler(invalid_parameter_handler)),
-                    old_report_mode(_CrtSetReportMode(_CRT_ASSERT, 0)) {
-                }
+            disable_invalid_parameter_handler() :
+                old_handler(_set_thread_local_invalid_parameter_handler(invalid_parameter_handler)),
+                old_report_mode(_CrtSetReportMode(_CRT_ASSERT, 0)) {
+            }
 
-                ~disable_invalid_parameter_handler() {
-                    _CrtSetReportMode(_CRT_ASSERT, old_report_mode);
-                    _set_thread_local_invalid_parameter_handler(old_handler);
-                }
+            ~disable_invalid_parameter_handler() {
+                _CrtSetReportMode(_CRT_ASSERT, old_report_mode);
+                _set_thread_local_invalid_parameter_handler(old_handler);
+            }
 
-            }; // class disable_invalid_parameter_handler
+        }; // class disable_invalid_parameter_handler
 
-        }
+    } // namespace detail
 #endif
 
+    inline namespace util {
+
         /**
          * Get file size.
          * This is a small wrapper around a system call.
@@ -109,7 +109,7 @@ namespace osmium {
         inline std::size_t file_size(int fd) {
 #ifdef _MSC_VER
             // Windows implementation
-            detail::disable_invalid_parameter_handler diph;
+            osmium::detail::disable_invalid_parameter_handler diph;
             // https://msdn.microsoft.com/en-us/library/dfbc2kec.aspx
             const auto size = ::_filelengthi64(fd);
             if (size < 0) {
@@ -118,7 +118,7 @@ namespace osmium {
             return static_cast<std::size_t>(size);
 #else
             // Unix implementation
-            struct stat s;
+            struct stat s; // NOLINT clang-tidy
             if (::fstat(fd, &s) != 0) {
                 throw std::system_error{errno, std::system_category(), "Could not get file size"};
             }
@@ -139,13 +139,13 @@ namespace osmium {
 #ifdef _MSC_VER
             // Windows implementation
             // https://msdn.microsoft.com/en-us/library/14h5k7ff.aspx
-            struct _stat64 s;
+            struct _stat64 s{};
             if (::_stati64(name, &s) != 0) {
                 throw std::system_error{errno, std::system_category(), std::string{"Could not get file size of file '"} + name + "'"};
             }
 #else
             // Unix implementation
-            struct stat s;
+            struct stat s; // NOLINT clang-tidy
             if (::stat(name, &s) != 0) {
                 throw std::system_error{errno, std::system_category(), std::string{"Could not get file size of file '"} + name + "'"};
             }
@@ -174,8 +174,8 @@ namespace osmium {
          * @throws std::system_error If ftruncate(2) call failed
          */
         inline void resize_file(int fd, std::size_t new_size) {
-#ifdef _WIN32
-            detail::disable_invalid_parameter_handler diph;
+#ifdef _MSC_VER
+            osmium::detail::disable_invalid_parameter_handler diph;
             // https://msdn.microsoft.com/en-us/library/whx354w1.aspx
             if (::_chsize_s(fd, static_cast_with_assert<__int64>(new_size)) != 0) {
 #else
@@ -208,7 +208,7 @@ namespace osmium {
          */
         inline std::size_t file_offset(int fd) {
 #ifdef _MSC_VER
-            detail::disable_invalid_parameter_handler diph;
+            osmium::detail::disable_invalid_parameter_handler diph;
             // https://msdn.microsoft.com/en-us/library/1yee101t.aspx
             const auto offset = _lseeki64(fd, 0, SEEK_CUR);
 #else
@@ -225,7 +225,7 @@ namespace osmium {
          */
         inline bool isatty(int fd) {
 #ifdef _MSC_VER
-            detail::disable_invalid_parameter_handler diph;
+            osmium::detail::disable_invalid_parameter_handler diph;
             // https://msdn.microsoft.com/en-us/library/f4s0ddew.aspx
             return _isatty(fd) != 0;
 #else
diff --git a/third_party/libosmium/include/osmium/util/iterator.hpp b/third_party/libosmium/include/osmium/util/iterator.hpp
index bd8a6927bc1..02bf2837050 100644
--- a/third_party/libosmium/include/osmium/util/iterator.hpp
+++ b/third_party/libosmium/include/osmium/util/iterator.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/memory.hpp b/third_party/libosmium/include/osmium/util/memory.hpp
index 1c2b9d87fd1..e1f1122906a 100644
--- a/third_party/libosmium/include/osmium/util/memory.hpp
+++ b/third_party/libosmium/include/osmium/util/memory.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -37,18 +37,20 @@ DEALINGS IN THE SOFTWARE.
 #include <fstream>
 #include <string>
 
+#include <osmium/util/misc.hpp>
+
 namespace osmium {
 
     class MemoryUsage {
 
-        int m_current = 0;
-        int m_peak    = 0;
+        int64_t m_current = 0;
+        int64_t m_peak    = 0;
 
 #ifdef __linux__
         static int parse_number(const std::string& line) {
             const auto f = line.find_first_of("0123456789");
             const auto l = line.find_last_of("0123456789");
-            return std::atoi(line.substr(f, l - f + 1).c_str());
+            return osmium::detail::str_to_int<int64_t>(line.substr(f, l - f + 1).c_str());
         }
 #endif
 
@@ -83,12 +85,12 @@ namespace osmium {
 
         /// Return current memory usage in MBytes
         int current() const {
-            return m_current / 1024;
+            return static_cast<int>(m_current / 1024);
         }
 
         /// Return peak memory usage in MBytes
         int peak() const {
-            return m_peak / 1024;
+            return static_cast<int>(m_peak / 1024);
         }
 
     }; // class MemoryUsage
diff --git a/third_party/libosmium/include/osmium/util/memory_mapping.hpp b/third_party/libosmium/include/osmium/util/memory_mapping.hpp
index c4059798eed..57c3262488f 100644
--- a/third_party/libosmium/include/osmium/util/memory_mapping.hpp
+++ b/third_party/libosmium/include/osmium/util/memory_mapping.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,15 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/compatibility.hpp>
+#include <osmium/util/file.hpp>
+
 #include <cassert>
 #include <cerrno>
 #include <cstddef>
 #include <stdexcept>
 #include <system_error>
 
-#include <osmium/util/compatibility.hpp>
-#include <osmium/util/file.hpp>
-
 #ifndef _WIN32
 # include <sys/mman.h>
 #else
@@ -53,7 +53,7 @@ DEALINGS IN THE SOFTWARE.
 
 namespace osmium {
 
-    namespace util {
+    inline namespace util {
 
         /**
          * Class for wrapping memory mapping system calls.
@@ -139,15 +139,15 @@ namespace osmium {
 
             static std::size_t check_size(std::size_t size) {
                 if (size == 0) {
-                    return osmium::util::get_pagesize();
+                    return osmium::get_pagesize();
                 }
                 return size;
             }
 
 #ifdef _WIN32
             HANDLE get_handle() const noexcept;
-            HANDLE osmium::util::MemoryMapping::create_file_mapping() const noexcept;
-            void* osmium::util::MemoryMapping::map_view_of_file() const noexcept;
+            HANDLE create_file_mapping() const noexcept;
+            void* map_view_of_file() const noexcept;
 #endif
 
             int resize_fd(int fd) {
@@ -157,8 +157,8 @@ namespace osmium {
                 }
 
                 // Make sure the file backing this mapping is large enough.
-                if (osmium::util::file_size(fd) < m_size + m_offset) {
-                    osmium::util::resize_file(fd, m_size + m_offset);
+                if (osmium::file_size(fd) < m_size + m_offset) {
+                    osmium::resize_file(fd, m_size + m_offset);
                 }
                 return fd;
             }
@@ -181,14 +181,14 @@ namespace osmium {
              * @param offset Offset into the file where the mapping should start
              * @throws std::system_error if the mapping fails
              */
-            MemoryMapping(std::size_t size, mapping_mode mode, int fd=-1, off_t offset=0);
+            MemoryMapping(std::size_t size, mapping_mode mode, int fd = -1, off_t offset = 0);
 
             /**
              * @deprecated
              * For backwards compatibility only. Use the constructor taking
              * a mapping_mode as second argument instead.
              */
-            OSMIUM_DEPRECATED MemoryMapping(std::size_t size, bool writable=true, int fd=-1, off_t offset=0) :
+            OSMIUM_DEPRECATED MemoryMapping(std::size_t size, bool writable = true, int fd = -1, off_t offset = 0) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
                 MemoryMapping(size, writable ? mapping_mode::write_shared : mapping_mode::readonly, fd, offset)  {
             }
 
@@ -202,12 +202,12 @@ namespace osmium {
              * Move construct a mapping from another one. The other mapping
              * will be marked as invalid.
              */
-            MemoryMapping(MemoryMapping&& other);
+            MemoryMapping(MemoryMapping&& other) noexcept;
 
             /**
              * Move a mapping. The other mapping will be marked as invalid.
              */
-            MemoryMapping& operator=(MemoryMapping&& other);
+            MemoryMapping& operator=(MemoryMapping&& other) noexcept;
 
             /**
              * Releases the mapping by calling unmap(). Will never throw.
@@ -373,19 +373,19 @@ namespace osmium {
             /// You can not copy construct a TypedMemoryMapping.
             TypedMemoryMapping(const TypedMemoryMapping&) = delete;
 
-            /// You can not copy a MemoryMapping.
+            /// You can not copy a TypedMemoryMapping.
             TypedMemoryMapping& operator=(const TypedMemoryMapping&) = delete;
 
             /**
              * Move construct a mapping from another one. The other mapping
              * will be marked as invalid.
              */
-            TypedMemoryMapping(TypedMemoryMapping&& other) = default;
+            TypedMemoryMapping(TypedMemoryMapping&& other) noexcept = default;
 
             /**
              * Move a mapping. The other mapping will be marked as invalid.
              */
-            TypedMemoryMapping& operator=(TypedMemoryMapping&& other) = default;
+            TypedMemoryMapping& operator=(TypedMemoryMapping&& other) noexcept = default;
 
             /**
              * Releases the mapping by calling unmap(). Will never throw.
@@ -518,12 +518,12 @@ namespace osmium {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 
-inline bool osmium::util::MemoryMapping::is_valid() const noexcept {
-    return m_addr != MAP_FAILED;
+inline bool osmium::MemoryMapping::is_valid() const noexcept {
+    return m_addr != MAP_FAILED; // NOLINT(cppcoreguidelines-pro-type-cstyle-cast)
 }
 
-inline void osmium::util::MemoryMapping::make_invalid() noexcept {
-    m_addr = MAP_FAILED;
+inline void osmium::MemoryMapping::make_invalid() noexcept {
+    m_addr = MAP_FAILED; // NOLINT(cppcoreguidelines-pro-type-cstyle-cast)
 }
 
 #pragma GCC diagnostic pop
@@ -533,16 +533,16 @@ inline void osmium::util::MemoryMapping::make_invalid() noexcept {
 # define MAP_ANONYMOUS MAP_ANON
 #endif
 
-inline int osmium::util::MemoryMapping::get_protection() const noexcept {
+inline int osmium::MemoryMapping::get_protection() const noexcept {
     if (m_mapping_mode == mapping_mode::readonly) {
         return PROT_READ;
     }
-    return PROT_READ | PROT_WRITE;
+    return PROT_READ | PROT_WRITE; // NOLINT(hicpp-signed-bitwise)
 }
 
-inline int osmium::util::MemoryMapping::get_flags() const noexcept {
+inline int osmium::MemoryMapping::get_flags() const noexcept {
     if (m_fd == -1) {
-        return MAP_PRIVATE | MAP_ANONYMOUS;
+        return MAP_PRIVATE | MAP_ANONYMOUS; // NOLINT(hicpp-signed-bitwise)
     }
     if (m_mapping_mode == mapping_mode::write_shared) {
         return MAP_SHARED;
@@ -550,7 +550,7 @@ inline int osmium::util::MemoryMapping::get_flags() const noexcept {
     return MAP_PRIVATE;
 }
 
-inline osmium::util::MemoryMapping::MemoryMapping(std::size_t size, mapping_mode mode, int fd, off_t offset) :
+inline osmium::MemoryMapping::MemoryMapping(std::size_t size, mapping_mode mode, int fd, off_t offset) :
     m_size(check_size(size)),
     m_offset(offset),
     m_fd(resize_fd(fd)),
@@ -562,7 +562,7 @@ inline osmium::util::MemoryMapping::MemoryMapping(std::size_t size, mapping_mode
     }
 }
 
-inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) :
+inline osmium::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
     m_size(other.m_size),
     m_offset(other.m_offset),
     m_fd(other.m_fd),
@@ -571,7 +571,7 @@ inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) :
     other.make_invalid();
 }
 
-inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmium::util::MemoryMapping&& other) {
+inline osmium::MemoryMapping& osmium::MemoryMapping::operator=(osmium::MemoryMapping&& other) noexcept {
     unmap();
     m_size         = other.m_size;
     m_offset       = other.m_offset;
@@ -582,7 +582,7 @@ inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmiu
     return *this;
 }
 
-inline void osmium::util::MemoryMapping::unmap() {
+inline void osmium::MemoryMapping::unmap() {
     if (is_valid()) {
         if (::munmap(m_addr, m_size) != 0) {
             throw std::system_error{errno, std::system_category(), "munmap failed"};
@@ -591,7 +591,7 @@ inline void osmium::util::MemoryMapping::unmap() {
     }
 }
 
-inline void osmium::util::MemoryMapping::resize(std::size_t new_size) {
+inline void osmium::MemoryMapping::resize(std::size_t new_size) {
     assert(new_size > 0 && "can not resize to zero size");
     if (m_fd == -1) { // anonymous mapping
 #ifdef __linux__
@@ -619,15 +619,15 @@ inline void osmium::util::MemoryMapping::resize(std::size_t new_size) {
 // =========== Windows implementation =============
 
 /* References:
- * CreateFileMapping: http://msdn.microsoft.com/en-us/library/aa366537(VS.85).aspx
- * CloseHandle:       http://msdn.microsoft.com/en-us/library/ms724211(VS.85).aspx
- * MapViewOfFile:     http://msdn.microsoft.com/en-us/library/aa366761(VS.85).aspx
- * UnmapViewOfFile:   http://msdn.microsoft.com/en-us/library/aa366882(VS.85).aspx
+ * CreateFileMapping: https://msdn.microsoft.com/en-us/library/aa366537(VS.85).aspx
+ * CloseHandle:       https://msdn.microsoft.com/en-us/library/ms724211(VS.85).aspx
+ * MapViewOfFile:     https://msdn.microsoft.com/en-us/library/aa366761(VS.85).aspx
+ * UnmapViewOfFile:   https://msdn.microsoft.com/en-us/library/aa366882(VS.85).aspx
  */
 
 namespace osmium {
 
-    namespace util {
+    inline namespace util {
 
         inline DWORD dword_hi(uint64_t x) {
             return static_cast<DWORD>(x >> 32);
@@ -641,7 +641,7 @@ namespace osmium {
 
 } // namespace osmium
 
-inline DWORD osmium::util::MemoryMapping::get_protection() const noexcept {
+inline DWORD osmium::MemoryMapping::get_protection() const noexcept {
     switch (m_mapping_mode) {
         case mapping_mode::readonly:
             return PAGE_READONLY;
@@ -653,7 +653,7 @@ inline DWORD osmium::util::MemoryMapping::get_protection() const noexcept {
     return PAGE_READWRITE;
 }
 
-inline DWORD osmium::util::MemoryMapping::get_flags() const noexcept {
+inline DWORD osmium::MemoryMapping::get_flags() const noexcept {
     switch (m_mapping_mode) {
         case mapping_mode::readonly:
             return FILE_MAP_READ;
@@ -665,38 +665,38 @@ inline DWORD osmium::util::MemoryMapping::get_flags() const noexcept {
     return FILE_MAP_WRITE;
 }
 
-inline HANDLE osmium::util::MemoryMapping::get_handle() const noexcept {
+inline HANDLE osmium::MemoryMapping::get_handle() const noexcept {
     if (m_fd == -1) {
         return INVALID_HANDLE_VALUE;
     }
     return reinterpret_cast<HANDLE>(_get_osfhandle(m_fd));
 }
 
-inline HANDLE osmium::util::MemoryMapping::create_file_mapping() const noexcept {
+inline HANDLE osmium::MemoryMapping::create_file_mapping() const noexcept {
     if (m_fd != -1) {
         _setmode(m_fd, _O_BINARY);
     }
     return CreateFileMapping(get_handle(),
                              nullptr,
                              get_protection(),
-                             osmium::util::dword_hi(static_cast<uint64_t>(m_size) + m_offset),
-                             osmium::util::dword_lo(static_cast<uint64_t>(m_size) + m_offset),
+                             osmium::dword_hi(static_cast<uint64_t>(m_size) + m_offset),
+                             osmium::dword_lo(static_cast<uint64_t>(m_size) + m_offset),
                              nullptr);
 }
 
-inline void* osmium::util::MemoryMapping::map_view_of_file() const noexcept {
+inline void* osmium::MemoryMapping::map_view_of_file() const noexcept {
     return MapViewOfFile(m_handle,
                          get_flags(),
-                         osmium::util::dword_hi(m_offset),
-                         osmium::util::dword_lo(m_offset),
+                         osmium::dword_hi(m_offset),
+                         osmium::dword_lo(m_offset),
                          m_size);
 }
 
-inline bool osmium::util::MemoryMapping::is_valid() const noexcept {
+inline bool osmium::MemoryMapping::is_valid() const noexcept {
     return m_addr != nullptr;
 }
 
-inline void osmium::util::MemoryMapping::make_invalid() noexcept {
+inline void osmium::MemoryMapping::make_invalid() noexcept {
     m_addr = nullptr;
 }
 
@@ -707,7 +707,7 @@ inline int last_error() noexcept {
     return static_cast<int>(GetLastError());
 }
 
-inline osmium::util::MemoryMapping::MemoryMapping(std::size_t size, MemoryMapping::mapping_mode mode, int fd, off_t offset) :
+inline osmium::MemoryMapping::MemoryMapping(std::size_t size, MemoryMapping::mapping_mode mode, int fd, off_t offset) :
     m_size(check_size(size)),
     m_offset(offset),
     m_fd(resize_fd(fd)),
@@ -725,7 +725,7 @@ inline osmium::util::MemoryMapping::MemoryMapping(std::size_t size, MemoryMappin
     }
 }
 
-inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) :
+inline osmium::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
     m_size(other.m_size),
     m_offset(other.m_offset),
     m_fd(other.m_fd),
@@ -736,7 +736,7 @@ inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) :
     other.m_handle = nullptr;
 }
 
-inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmium::util::MemoryMapping&& other) {
+inline osmium::MemoryMapping& osmium::MemoryMapping::operator=(osmium::MemoryMapping&& other) noexcept {
     unmap();
     m_size         = other.m_size;
     m_offset       = other.m_offset;
@@ -749,7 +749,7 @@ inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmiu
     return *this;
 }
 
-inline void osmium::util::MemoryMapping::unmap() {
+inline void osmium::MemoryMapping::unmap() {
     if (is_valid()) {
         if (!UnmapViewOfFile(m_addr)) {
             throw std::system_error{last_error(), std::system_category(), "UnmapViewOfFile failed"};
@@ -765,7 +765,7 @@ inline void osmium::util::MemoryMapping::unmap() {
     }
 }
 
-inline void osmium::util::MemoryMapping::resize(std::size_t new_size) {
+inline void osmium::MemoryMapping::resize(std::size_t new_size) {
     unmap();
 
     m_size = new_size;
diff --git a/third_party/libosmium/include/osmium/util/minmax.hpp b/third_party/libosmium/include/osmium/util/minmax.hpp
index 833bc2a63e7..22c2ea44e3b 100644
--- a/third_party/libosmium/include/osmium/util/minmax.hpp
+++ b/third_party/libosmium/include/osmium/util/minmax.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/misc.hpp b/third_party/libosmium/include/osmium/util/misc.hpp
index 14192b4fe19..d0bdce8945f 100644
--- a/third_party/libosmium/include/osmium/util/misc.hpp
+++ b/third_party/libosmium/include/osmium/util/misc.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,7 +33,13 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <cassert>
+#include <cerrno>
+#include <cstdlib>
+#include <limits>
+#include <stdexcept>
 #include <tuple>
+#include <type_traits>
 
 namespace osmium {
 
@@ -47,6 +53,35 @@ namespace osmium {
         return std::tuple<const Ts&...>(args...);
     }
 
+    namespace detail {
+
+        /**
+         * Interpret the input string as number. Leading white space is
+         * ignored. If there is any error, return 0.
+         *
+         * @tparam TReturn The return type.
+         * @param str The input string.
+         *
+         * @pre @code str != nullptr @endcode
+         *
+         */
+
+        template <typename TReturn>
+        inline TReturn str_to_int(const char* str) {
+            static_assert(std::is_integral<TReturn>::value, "Must be integral type");
+            using r_type = typename std::conditional<std::is_unsigned<TReturn>::value, unsigned long long, long long>::type; // NOLINT(google-runtime-int)
+            assert(str);
+            char* end = nullptr;
+            const auto value = std::strtoll(str, &end, 10);
+            if (value < 0 || value == std::numeric_limits<long long>::max() || static_cast<r_type>(value) >= std::numeric_limits<TReturn>::max() || end == nullptr || *end != '\0') { // NOLINT(google-runtime-int)
+                return 0;
+            }
+
+            return static_cast<TReturn>(value);
+        }
+
+    } // namespace detail
+
 } // namespace osmium
 
 #endif // OSMIUM_UTIL_MISC_HPP
diff --git a/third_party/libosmium/include/osmium/util/options.hpp b/third_party/libosmium/include/osmium/util/options.hpp
index c39bdbf6fc2..0e99be21b39 100644
--- a/third_party/libosmium/include/osmium/util/options.hpp
+++ b/third_party/libosmium/include/osmium/util/options.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -41,7 +41,7 @@ DEALINGS IN THE SOFTWARE.
 
 namespace osmium {
 
-    namespace util {
+    inline namespace util {
 
         /**
          * Stores key=value type options. This class can be used stand-alone or
@@ -77,7 +77,7 @@ namespace osmium {
              *   Options options{ { "foo", "true" }, { "bar", "17" } };
              * @endcode
              */
-            explicit Options(const std::initializer_list<value_type>& values) :
+            Options(const std::initializer_list<value_type>& values) :
                 m_options(values) {
             }
 
@@ -112,7 +112,7 @@ namespace osmium {
                 if (pos == std::string::npos) {
                     m_options[data] = "true";
                 } else {
-                    const std::string value{data.substr(pos+1)};
+                    const std::string value{data.substr(pos + 1)};
                     set(data.substr(0, pos), value);
                 }
             }
diff --git a/third_party/libosmium/include/osmium/util/progress_bar.hpp b/third_party/libosmium/include/osmium/util/progress_bar.hpp
index fed37eb4c9e..1c246f40d19 100644
--- a/third_party/libosmium/include/osmium/util/progress_bar.hpp
+++ b/third_party/libosmium/include/osmium/util/progress_bar.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,7 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <cassert>
 #include <cstddef>
 #include <iostream>
 
@@ -44,15 +45,19 @@ namespace osmium {
      */
     class ProgressBar {
 
-        static const char* bar() noexcept {
-            return "======================================================================";
-        }
+        static constexpr const std::size_t full_length = 70;
 
-        static const char* spc() noexcept {
-            return "                                                                     ";
+        static const char* bar(std::size_t len = full_length) noexcept {
+            assert(len <= full_length);
+            return "======================================================================"
+                   + full_length - len;
         }
 
-        static constexpr const std::size_t length = 70;
+        static const char* spc(std::size_t len = full_length) noexcept {
+            assert(len >= 1 && len <= full_length);
+            return "                                                                     "
+                   + full_length - len;
+        }
 
         // The max size is the file size if there is a single file and the
         // sum of all file sizes if there are multiple files. It corresponds
@@ -84,12 +89,12 @@ namespace osmium {
             }
             m_prev_percent = percent;
 
-            const auto num = static_cast<std::size_t>(percent * (length / 100.0));
+            const auto num = static_cast<std::size_t>(percent * (full_length / 100.0));
             std::cerr << '[';
-            if (num >= length) {
+            if (num >= full_length) {
                 std::cerr << bar();
             } else {
-                std::cerr << (bar() + length - num) << '>' << (spc() + num);
+                std::cerr << bar(num) << '>' << spc(full_length - num);
             }
             std::cerr << "] ";
             if (percent < 10) {
@@ -115,6 +120,12 @@ namespace osmium {
             m_enable(max_size > 0 && enable) {
         }
 
+        ProgressBar(const ProgressBar&) = delete;
+        ProgressBar& operator=(const ProgressBar&) = delete;
+
+        ProgressBar(ProgressBar&&) noexcept = default;
+        ProgressBar& operator=(ProgressBar&&) = default;
+
         ~ProgressBar() {
             if (m_do_cleanup) {
                 try {
diff --git a/third_party/libosmium/include/osmium/util/string.hpp b/third_party/libosmium/include/osmium/util/string.hpp
index 6eef05f2185..9513166c403 100644
--- a/third_party/libosmium/include/osmium/util/string.hpp
+++ b/third_party/libosmium/include/osmium/util/string.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -55,7 +55,7 @@ namespace osmium {
             std::size_t nextpos = str.find_first_of(sep);
             while (nextpos != std::string::npos) {
                 if (!compact || (nextpos - pos != 0)) {
-                    tokens.push_back(str.substr(pos, nextpos-pos));
+                    tokens.push_back(str.substr(pos, nextpos - pos));
                 }
                 pos = nextpos + 1;
                 nextpos = str.find_first_of(sep, pos);
@@ -84,7 +84,7 @@ namespace osmium {
             std::size_t nextpos = str.find_first_of(sep);
             while (nextpos != std::string::npos) {
                 if (!compact || (nextpos - pos != 0)) {
-                    tokens.push_back(str.substr(pos, nextpos-pos));
+                    tokens.push_back(str.substr(pos, nextpos - pos));
                 }
                 pos = nextpos + 1;
                 nextpos = str.find_first_of(sep, pos);
diff --git a/third_party/libosmium/include/osmium/util/string_matcher.hpp b/third_party/libosmium/include/osmium/util/string_matcher.hpp
index 1aff423a3b7..2bb318b7dde 100644
--- a/third_party/libosmium/include/osmium/util/string_matcher.hpp
+++ b/third_party/libosmium/include/osmium/util/string_matcher.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,17 +33,19 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <boost/variant.hpp>
+
 #include <cstring>
 #include <iosfwd>
+#include <regex>
 #include <string>
+#include <utility>
 #include <vector>
 
-#include <regex>
-
 // std::regex isn't implemented properly in glibc++ (before the version
 // delivered with GCC 4.9) and libc++ before the version 3.6, so the use is
 // disabled by these checks. Checks for GLIBC were based on
-// http://stackoverflow.com/questions/12530406/is-gcc-4-8-or-earlier-buggy-about-regular-expressions
+// https://stackoverflow.com/questions/12530406/is-gcc-4-8-or-earlier-buggy-about-regular-expressions
 // Checks for libc++ are simply based on compiler defines. This is probably
 // not optimal but seems to work for now.
 #if defined(__GLIBCXX__)
@@ -63,8 +65,6 @@ DEALINGS IN THE SOFTWARE.
 # endif
 #endif
 
-#include <boost/variant.hpp>
-
 namespace osmium {
 
     /**
@@ -123,8 +123,8 @@ namespace osmium {
 
         public:
 
-            explicit equal(const std::string& str) :
-                m_str(str) {
+            explicit equal(std::string str) :
+                m_str(std::move(str)) {
             }
 
             explicit equal(const char* str) :
@@ -151,8 +151,8 @@ namespace osmium {
 
         public:
 
-            explicit prefix(const std::string& str) :
-                m_str(str) {
+            explicit prefix(std::string str) :
+                m_str(std::move(str)) {
             }
 
             explicit prefix(const char* str) :
@@ -179,8 +179,8 @@ namespace osmium {
 
         public:
 
-            explicit substring(const std::string& str) :
-                m_str(str) {
+            explicit substring(std::string str) :
+                m_str(std::move(str)) {
             }
 
             explicit substring(const char* str) :
@@ -208,8 +208,8 @@ namespace osmium {
 
         public:
 
-            explicit regex(const std::regex& regex) :
-                m_regex(regex) {
+            explicit regex(std::regex regex) :
+                m_regex(std::move(regex)) {
             }
 
             bool match(const char* test_string) const noexcept {
@@ -233,16 +233,14 @@ namespace osmium {
 
         public:
 
-            explicit list() :
-                m_strings() {
-            }
+            explicit list() = default;
 
-            explicit list(const std::vector<std::string>& strings) :
-                m_strings(strings) {
+            explicit list(std::vector<std::string> strings) :
+                m_strings(std::move(strings)) {
             }
 
             list& add_string(const char* str) {
-                m_strings.push_back(str);
+                m_strings.emplace_back(str);
                 return *this;
             }
 
@@ -292,7 +290,7 @@ namespace osmium {
 
         public:
 
-            match_visitor(const char* str) noexcept :
+            explicit match_visitor(const char* str) noexcept :
                 m_str(str) {
             }
 
@@ -310,7 +308,7 @@ namespace osmium {
 
         public:
 
-            print_visitor(std::basic_ostream<TChar, TTraits>& out) :
+            explicit print_visitor(std::basic_ostream<TChar, TTraits>& out) :
                 m_out(&out) {
             }
 
@@ -338,7 +336,7 @@ namespace osmium {
          * or
          * @code StringMatcher{StringMatcher::always_false}; @endcode
          */
-        StringMatcher(bool result) :
+        StringMatcher(bool result) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(always_false{}) {
             if (result) {
                 m_matcher = always_true{};
@@ -350,7 +348,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::equal{str}}; @endcode
          */
-        StringMatcher(const char* str) :
+        StringMatcher(const char* str) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(equal{str}) {
         }
 
@@ -359,7 +357,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::equal{str}}; @endcode
          */
-        StringMatcher(const std::string& str) :
+        StringMatcher(const std::string& str) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(equal{str}) {
         }
 
@@ -369,7 +367,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::regex{aregex}}; @endcode
          */
-        StringMatcher(const std::regex& aregex) :
+        StringMatcher(const std::regex& aregex) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(regex{aregex}) {
         }
 #endif
@@ -380,7 +378,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::list{strings}}; @endcode
          */
-        StringMatcher(const std::vector<std::string>& strings) :
+        StringMatcher(const std::vector<std::string>& strings) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(list{strings}) {
         }
 
@@ -393,7 +391,7 @@ namespace osmium {
          */
         template <typename TMatcher, typename std::enable_if<
             std::is_base_of<matcher, TMatcher>::value, int>::type = 0>
-        StringMatcher(TMatcher&& matcher) :
+        StringMatcher(TMatcher&& matcher) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions, misc-forwarding-reference-overload)
             m_matcher(std::forward<TMatcher>(matcher)) {
         }
 
diff --git a/third_party/libosmium/include/osmium/util/timer.hpp b/third_party/libosmium/include/osmium/util/timer.hpp
index 13ea8b9a20f..01661727b54 100644
--- a/third_party/libosmium/include/osmium/util/timer.hpp
+++ b/third_party/libosmium/include/osmium/util/timer.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/verbose_output.hpp b/third_party/libosmium/include/osmium/util/verbose_output.hpp
index e6f6654a0c9..066f1158fb2 100644
--- a/third_party/libosmium/include/osmium/util/verbose_output.hpp
+++ b/third_party/libosmium/include/osmium/util/verbose_output.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -44,7 +44,7 @@ namespace osmium {
     /**
      * @brief Helpful utility classes and functions not strictly OSM related
      */
-    namespace util {
+    inline namespace util {
 
         /**
          * Osmium programs often run for a long time because of the amount of
@@ -93,13 +93,6 @@ namespace osmium {
                 m_newline(true) {
             }
 
-            ~VerboseOutput() = default;
-
-            VerboseOutput(const VerboseOutput&) = default;
-            VerboseOutput& operator=(const VerboseOutput&) = default;
-            VerboseOutput(VerboseOutput&&) = default;
-            VerboseOutput& operator=(VerboseOutput&&) = default;
-
             time_t runtime() const noexcept {
                 return time(nullptr) - m_start;
             }
@@ -114,7 +107,7 @@ namespace osmium {
                 m_verbose = verbose;
             }
 
-            template<typename T>
+            template <typename T>
             void print(const T& value) {
                 if (m_verbose) {
                     start_line();
@@ -131,7 +124,7 @@ namespace osmium {
 
         }; // class VerboseOutput
 
-        template<typename T>
+        template <typename T>
         inline VerboseOutput& operator<<(VerboseOutput& verbose_output, const T& value) {
             verbose_output.print(value);
             return verbose_output;
diff --git a/third_party/libosmium/include/osmium/version.hpp b/third_party/libosmium/include/osmium/version.hpp
index 004ad0ed4e9..877b66e6122 100644
--- a/third_party/libosmium/include/osmium/version.hpp
+++ b/third_party/libosmium/include/osmium/version.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,9 +34,9 @@ DEALINGS IN THE SOFTWARE.
 */
 
 #define LIBOSMIUM_VERSION_MAJOR 2
-#define LIBOSMIUM_VERSION_MINOR 13
-#define LIBOSMIUM_VERSION_PATCH 1
+#define LIBOSMIUM_VERSION_MINOR 14
+#define LIBOSMIUM_VERSION_PATCH 0
 
-#define LIBOSMIUM_VERSION_STRING "2.13.1"
+#define LIBOSMIUM_VERSION_STRING "2.14.0"
 
 #endif // OSMIUM_VERSION_HPP
diff --git a/third_party/libosmium/include/osmium/visitor.hpp b/third_party/libosmium/include/osmium/visitor.hpp
index fa2d765adde..6ea2c2565f2 100644
--- a/third_party/libosmium/include/osmium/visitor.hpp
+++ b/third_party/libosmium/include/osmium/visitor.hpp
@@ -5,7 +5,7 @@
 
 This file is part of Osmium (http://osmcode.org/libosmium).
 
-Copyright 2013-2017 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,9 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <type_traits>
-#include <utility>
-
 #include <osmium/fwd.hpp>
 #include <osmium/io/reader_iterator.hpp> // IWYU pragma: keep
 #include <osmium/memory/buffer.hpp>
@@ -43,6 +40,9 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/entity.hpp>
 #include <osmium/osm/item_type.hpp>
 
+#include <type_traits>
+#include <utility>
+
 namespace osmium {
 
     namespace detail {
@@ -224,7 +224,9 @@ namespace osmium {
 
     template <typename TContainer, typename... THandlers>
     inline void apply(TContainer& c, THandlers&&... handlers) {
-        apply(std::begin(c), std::end(c), std::forward<THandlers>(handlers)...);
+        using std::begin;
+        using std::end;
+        apply(begin(c), end(c), std::forward<THandlers>(handlers)...);
     }
 
     template <typename... THandlers>
diff --git a/third_party/libosmium/include/protozero/pbf_message.hpp b/third_party/libosmium/include/protozero/pbf_message.hpp
deleted file mode 100644
index c599cf1efa5..00000000000
--- a/third_party/libosmium/include/protozero/pbf_message.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef PROTOZERO_PBF_MESSAGE_HPP
-#define PROTOZERO_PBF_MESSAGE_HPP
-
-/*****************************************************************************
-
-protozero - Minimalistic protocol buffer decoder and encoder in C++.
-
-This file is from https://github.com/mapbox/protozero where you can find more
-documentation.
-
-*****************************************************************************/
-
-/**
- * @file pbf_message.hpp
- *
- * @brief Contains the pbf_message template class.
- */
-
-#include <type_traits>
-
-#include <protozero/pbf_reader.hpp>
-#include <protozero/types.hpp>
-
-namespace protozero {
-
-/**
- * This class represents a protobuf message. Either a top-level message or
- * a nested sub-message. Top-level messages can be created from any buffer
- * with a pointer and length:
- *
- * @code
- *    enum class Message : protozero::pbf_tag_type {
- *       ...
- *    };
- *
- *    std::string buffer;
- *    // fill buffer...
- *    pbf_message<Message> message(buffer.data(), buffer.size());
- * @endcode
- *
- * Sub-messages are created using get_message():
- *
- * @code
- *    enum class SubMessage : protozero::pbf_tag_type {
- *       ...
- *    };
- *
- *    pbf_message<Message> message(...);
- *    message.next();
- *    pbf_message<SubMessage> submessage = message.get_message();
- * @endcode
- *
- * All methods of the pbf_message class except get_bytes() and get_string()
- * provide the strong exception guarantee, ie they either succeed or do not
- * change the pbf_message object they are called on. Use the get_data() method
- * instead of get_bytes() or get_string(), if you need this guarantee.
- *
- * This template class is based on the pbf_reader class and has all the same
- * methods. The difference is that whereever the pbf_reader class takes an
- * integer tag, this template class takes a tag of the template type T.
- *
- * Read the tutorial to understand how this class is used.
- */
-template <typename T>
-class pbf_message : public pbf_reader {
-
-    static_assert(std::is_same<pbf_tag_type, typename std::underlying_type<T>::type>::value, "T must be enum with underlying type protozero::pbf_tag_type");
-
-public:
-
-    using enum_type = T;
-
-    template <typename... Args>
-    pbf_message(Args&&... args) noexcept :
-        pbf_reader(std::forward<Args>(args)...) {
-    }
-
-    bool next() {
-        return pbf_reader::next();
-    }
-
-    bool next(T next_tag) {
-        return pbf_reader::next(pbf_tag_type(next_tag));
-    }
-
-    bool next(T next_tag, pbf_wire_type type) {
-        return pbf_reader::next(pbf_tag_type(next_tag), type);
-    }
-
-    T tag() const noexcept {
-        return T(pbf_reader::tag());
-    }
-
-}; // class pbf_message
-
-} // end namespace protozero
-
-#endif // PROTOZERO_PBF_MESSAGE_HPP
diff --git a/third_party/libosmium/osmium.imp b/third_party/libosmium/osmium.imp
index 77c5c37aaaf..e63cf7ff5ca 100644
--- a/third_party/libosmium/osmium.imp
+++ b/third_party/libosmium/osmium.imp
@@ -2,7 +2,7 @@
 #
 #  Configuration for Include-What-You-Use tool
 #
-#  http://include-what-you-use.org/
+#  https://include-what-you-use.org/
 #
 #-----------------------------------------------------------------------------
 [
diff --git a/third_party/libosmium/test/CMakeLists.txt b/third_party/libosmium/test/CMakeLists.txt
index b23c39a662b..bd75a8bfe3c 100644
--- a/third_party/libosmium/test/CMakeLists.txt
+++ b/third_party/libosmium/test/CMakeLists.txt
@@ -9,6 +9,8 @@
 message(STATUS "Configuring unit tests")
 
 include(CMakeParseArguments)
+
+include_directories(SYSTEM catch)
 include_directories(include)
 
 add_library(testlib STATIC test_main.cpp)
@@ -20,6 +22,10 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     add_definitions(-Wno-parentheses)
 endif()
 
+if(NOT MSVC)
+    add_definitions(-Wno-deprecated-declarations)
+endif()
+
 
 #-----------------------------------------------------------------------------
 #
@@ -131,6 +137,7 @@ add_unit_test(osm test_changeset)
 add_unit_test(osm test_crc)
 add_unit_test(osm test_entity_bits)
 add_unit_test(osm test_location)
+add_unit_test(osm test_metadata)
 add_unit_test(osm test_node)
 add_unit_test(osm test_node_ref)
 add_unit_test(osm test_object_comparisons)
@@ -175,6 +182,7 @@ add_unit_test(index test_relations_map)
 add_unit_test(io test_compression_factory)
 add_unit_test(io test_bzip2 ENABLE_IF ${BZIP2_FOUND} LIBS ${BZIP2_LIBRARIES})
 add_unit_test(io test_file_formats)
+add_unit_test(io test_pbf ENABLE_IF ${Threads_FOUND} LIBS ${OSMIUM_PBF_LIBRARIES})
 add_unit_test(io test_reader LIBS "${OSMIUM_XML_LIBRARIES};${OSMIUM_PBF_LIBRARIES}")
 add_unit_test(io test_reader_fileformat ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
 add_unit_test(io test_reader_with_mock_decompression ENABLE_IF ${Threads_FOUND} LIBS ${OSMIUM_XML_LIBRARIES})
@@ -201,6 +209,7 @@ add_unit_test(tags test_tag_matcher)
 add_unit_test(tags test_tags_filter)
 
 add_unit_test(thread test_pool ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
+add_unit_test(thread test_queue ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
 add_unit_test(thread test_util ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
 
 add_unit_test(util test_cast_with_assert)
@@ -211,6 +220,7 @@ add_unit_test(util test_file)
 add_unit_test(util test_memory)
 add_unit_test(util test_memory_mapping)
 add_unit_test(util test_minmax)
+add_unit_test(util test_misc)
 add_unit_test(util test_options)
 add_unit_test(util test_string)
 add_unit_test(util test_string_matcher)
diff --git a/third_party/libosmium/test/README b/third_party/libosmium/test/README
index 868b533f29e..69e903607a6 100644
--- a/third_party/libosmium/test/README
+++ b/third_party/libosmium/test/README
@@ -1,5 +1,8 @@
-Osmium uses Catch (https://github.com/philsquared/Catch/) for its unit tests.
+Osmium uses Catch (https://github.com/catchorg/Catch2/) for its unit tests.
+
+Currently we are still using version 1.
 
 Only one header file is needed (catch.hpp) which can be downloaded from
-http://builds.catch-lib.net/ and put into the include directory.
+https://github.com/catchorg/Catch2/tree/Catch1.x and put into the include
+directory.
 
diff --git a/third_party/libosmium/test/catch/catch.hpp b/third_party/libosmium/test/catch/catch.hpp
new file mode 100644
index 00000000000..f619f237e6b
--- /dev/null
+++ b/third_party/libosmium/test/catch/catch.hpp
@@ -0,0 +1,11685 @@
+/*
+ *  Catch v1.12.1
+ *  Generated: 2018-03-02 21:17:41.036711
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
+#define TWOBLUECUBES_CATCH_HPP_INCLUDED
+
+#ifdef __clang__
+#    pragma clang system_header
+#elif defined __GNUC__
+#    pragma GCC system_header
+#endif
+
+// #included from: internal/catch_suppress_warnings.h
+
+#ifdef __clang__
+#   ifdef __ICC // icpc defines the __clang__ macro
+#       pragma warning(push)
+#       pragma warning(disable: 161 1682)
+#   else // __ICC
+#       pragma clang diagnostic ignored "-Wglobal-constructors"
+#       pragma clang diagnostic ignored "-Wvariadic-macros"
+#       pragma clang diagnostic ignored "-Wc99-extensions"
+#       pragma clang diagnostic ignored "-Wunused-variable"
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wpadded"
+#       pragma clang diagnostic ignored "-Wc++98-compat"
+#       pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#       pragma clang diagnostic ignored "-Wswitch-enum"
+#       pragma clang diagnostic ignored "-Wcovered-switch-default"
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic ignored "-Wvariadic-macros"
+#    pragma GCC diagnostic ignored "-Wunused-variable"
+#    pragma GCC diagnostic ignored "-Wparentheses"
+
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wpadded"
+#endif
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#endif
+
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// #included from: internal/catch_notimplemented_exception.h
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
+
+// #included from: catch_common.h
+#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
+
+// #included from: catch_compiler_capabilities.h
+#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported?
+// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
+// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
+// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported?
+// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported
+// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported?
+// CATCH_CONFIG_CPP11_OVERRIDE : is override supported?
+// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
+// CATCH_CONFIG_CPP11_SHUFFLE : is std::shuffle supported?
+// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if supported?
+
+// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
+
+// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?
+// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11
+
+#ifdef __cplusplus
+
+#  if __cplusplus >= 201103L
+#    define CATCH_CPP11_OR_GREATER
+#  endif
+
+#  if __cplusplus >= 201402L
+#    define CATCH_CPP14_OR_GREATER
+#  endif
+
+#endif
+
+#ifdef __clang__
+
+#  if __has_feature(cxx_nullptr)
+#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#  endif
+
+#  if __has_feature(cxx_noexcept)
+#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#  endif
+
+#   if defined(CATCH_CPP11_OR_GREATER)
+#       define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
+
+#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
+#   endif
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__)
+
+#   if !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#   endif
+
+#endif
+
+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+#   define _BSD_SOURCE
+
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Borland
+#ifdef __BORLANDC__
+
+#endif // __BORLANDC__
+
+////////////////////////////////////////////////////////////////////////////////
+// EDG
+#ifdef __EDG_VERSION__
+
+#endif // __EDG_VERSION__
+
+////////////////////////////////////////////////////////////////////////////////
+// Digital Mars
+#ifdef __DMC__
+
+#endif // __DMC__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#   if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#       define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#   endif
+
+// - otherwise more recent versions define __cplusplus >= 201103L
+// and will get picked up below
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+
+#if (_MSC_VER >= 1600)
+#   define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#   define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
+#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
+#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
+#endif
+
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use variadic macros if the compiler supports them
+#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
+    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
+    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
+
+#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+
+#endif
+
+// Use __COUNTER__ if the compiler supports it
+#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \
+    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
+    ( defined __clang__ && __clang_major__ >= 3 )
+
+// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former,
+// because __COUNTER__ is not properly handled by it.
+// This does not affect compilation
+#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// C++ language feature support
+
+// catch all support for C++11
+#if defined(CATCH_CPP11_OR_GREATER)
+
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR)
+#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#    define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
+#    define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE
+#    define CATCH_INTERNAL_CONFIG_CPP11_TUPLE
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+#    define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+#  endif
+
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG)
+#    define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG
+#  endif
+
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE)
+#    define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE
+#  endif
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
+#    define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#  endif
+# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE)
+#   define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
+#  endif
+# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS)
+#  define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
+# endif
+
+#endif // __cplusplus >= 201103L
+
+// Now set the actual defines based on the above + anything the user has configured
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_NULLPTR
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_NOEXCEPT
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_GENERATED_METHODS
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_IS_ENUM
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_TUPLE
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS)
+#   define CATCH_CONFIG_VARIADIC_MACROS
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_LONG_LONG
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_OVERRIDE
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_UNIQUE_PTR
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
+#   define CATCH_CONFIG_COUNTER
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_SHUFFLE
+#endif
+# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11)
+#  define CATCH_CONFIG_CPP11_TYPE_TRAITS
+# endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#   define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+#endif
+
+// noexcept support:
+#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
+#  define CATCH_NOEXCEPT noexcept
+#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
+#else
+#  define CATCH_NOEXCEPT throw()
+#  define CATCH_NOEXCEPT_IS(x)
+#endif
+
+// nullptr support
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+#   define CATCH_NULL nullptr
+#else
+#   define CATCH_NULL NULL
+#endif
+
+// override support
+#ifdef CATCH_CONFIG_CPP11_OVERRIDE
+#   define CATCH_OVERRIDE override
+#else
+#   define CATCH_OVERRIDE
+#endif
+
+// unique_ptr support
+#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR
+#   define CATCH_AUTO_PTR( T ) std::unique_ptr<T>
+#else
+#   define CATCH_AUTO_PTR( T ) std::auto_ptr<T>
+#endif
+
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
+#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
+
+#include <sstream>
+#include <algorithm>
+
+namespace Catch {
+
+    struct IConfig;
+
+    struct CaseSensitive { enum Choice {
+        Yes,
+        No
+    }; };
+
+    class NonCopyable {
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+#else
+        NonCopyable( NonCopyable const& info );
+        NonCopyable& operator = ( NonCopyable const& );
+#endif
+
+    protected:
+        NonCopyable() {}
+        virtual ~NonCopyable();
+    };
+
+    class SafeBool {
+    public:
+        typedef void (SafeBool::*type)() const;
+
+        static type makeSafe( bool value ) {
+            return value ? &SafeBool::trueValue : 0;
+        }
+    private:
+        void trueValue() const {}
+    };
+
+    template<typename ContainerT>
+    void deleteAll( ContainerT& container ) {
+        typename ContainerT::const_iterator it = container.begin();
+        typename ContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete *it;
+    }
+    template<typename AssociativeContainerT>
+    void deleteAllValues( AssociativeContainerT& container ) {
+        typename AssociativeContainerT::const_iterator it = container.begin();
+        typename AssociativeContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete it->second;
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( std::string const& s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    std::string trim( std::string const& str );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo();
+        SourceLineInfo( char const* _file, std::size_t _line );
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        SourceLineInfo(SourceLineInfo const& other)          = default;
+        SourceLineInfo( SourceLineInfo && )                  = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
+        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
+#  endif
+        bool empty() const;
+        bool operator == ( SourceLineInfo const& other ) const;
+        bool operator < ( SourceLineInfo const& other ) const;
+
+        char const* file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // This is just here to avoid compiler warnings with macro constants and boolean literals
+    inline bool isTrue( bool value ){ return value; }
+    inline bool alwaysTrue() { return true; }
+    inline bool alwaysFalse() { return false; }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );
+
+    void seedRng( IConfig const& config );
+    unsigned int rngSeed();
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() {
+            return std::string();
+        }
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );
+
+namespace Catch {
+
+    class NotImplementedException : public std::exception
+    {
+    public:
+        NotImplementedException( SourceLineInfo const& lineInfo );
+
+        virtual ~NotImplementedException() CATCH_NOEXCEPT {}
+
+        virtual const char* what() const CATCH_NOEXCEPT;
+
+    private:
+        std::string m_what;
+        SourceLineInfo m_lineInfo;
+    };
+
+} // end namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
+
+// #included from: internal/catch_context.h
+#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
+
+// #included from: catch_interfaces_generators.h
+#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct IGeneratorInfo {
+        virtual ~IGeneratorInfo();
+        virtual bool moveNext() = 0;
+        virtual std::size_t getCurrentIndex() const = 0;
+    };
+
+    struct IGeneratorsForTest {
+        virtual ~IGeneratorsForTest();
+
+        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
+        virtual bool moveNext() = 0;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest();
+
+} // end namespace Catch
+
+// #included from: catch_ptr.hpp
+#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    // An intrusive reference counting smart pointer.
+    // T must implement addRef() and release() methods
+    // typically implementing the IShared interface
+    template<typename T>
+    class Ptr {
+    public:
+        Ptr() : m_p( CATCH_NULL ){}
+        Ptr( T* p ) : m_p( p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        Ptr( Ptr const& other ) : m_p( other.m_p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        ~Ptr(){
+            if( m_p )
+                m_p->release();
+        }
+        void reset() {
+            if( m_p )
+                m_p->release();
+            m_p = CATCH_NULL;
+        }
+        Ptr& operator = ( T* p ){
+            Ptr temp( p );
+            swap( temp );
+            return *this;
+        }
+        Ptr& operator = ( Ptr const& other ){
+            Ptr temp( other );
+            swap( temp );
+            return *this;
+        }
+        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
+        T* get() const{ return m_p; }
+        T& operator*() const { return *m_p; }
+        T* operator->() const { return m_p; }
+        bool operator !() const { return m_p == CATCH_NULL; }
+        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); }
+
+    private:
+        T* m_p;
+    };
+
+    struct IShared : NonCopyable {
+        virtual ~IShared();
+        virtual void addRef() const = 0;
+        virtual void release() const = 0;
+    };
+
+    template<typename T = IShared>
+    struct SharedImpl : T {
+
+        SharedImpl() : m_rc( 0 ){}
+
+        virtual void addRef() const {
+            ++m_rc;
+        }
+        virtual void release() const {
+            if( --m_rc == 0 )
+                delete this;
+        }
+
+        mutable unsigned int m_rc;
+    };
+
+} // end namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace Catch {
+
+    class TestCase;
+    class Stream;
+    struct IResultCapture;
+    struct IRunner;
+    struct IGeneratorsForTest;
+    struct IConfig;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
+        virtual bool advanceGeneratorsForCurrentTest() = 0;
+        virtual Ptr<IConfig const> getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
+    };
+
+    IContext& getCurrentContext();
+    IMutableContext& getCurrentMutableContext();
+    void cleanUpContext();
+    Stream createStream( std::string const& streamName );
+
+}
+
+// #included from: internal/catch_test_registry.hpp
+#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_interfaces_testcase.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestCase : IShared {
+        virtual void invoke () const = 0;
+    protected:
+        virtual ~ITestCase();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+}
+
+namespace Catch {
+
+template<typename C>
+class MethodTestCase : public SharedImpl<ITestCase> {
+
+public:
+    MethodTestCase( void (C::*method)() ) : m_method( method ) {}
+
+    virtual void invoke() const {
+        C obj;
+        (obj.*m_method)();
+    }
+
+private:
+    virtual ~MethodTestCase() {}
+
+    void (C::*m_method)();
+};
+
+typedef void(*TestFunction)();
+
+struct NameAndDesc {
+    NameAndDesc( const char* _name = "", const char* _description= "" )
+    : name( _name ), description( _description )
+    {}
+
+    const char* name;
+    const char* description;
+};
+
+void registerTestCase
+    (   ITestCase* testCase,
+        char const* className,
+        NameAndDesc const& nameAndDesc,
+        SourceLineInfo const& lineInfo );
+
+struct AutoReg {
+
+    AutoReg
+        (   TestFunction function,
+            SourceLineInfo const& lineInfo,
+            NameAndDesc const& nameAndDesc );
+
+    template<typename C>
+    AutoReg
+        (   void (C::*method)(),
+            char const* className,
+            NameAndDesc const& nameAndDesc,
+            SourceLineInfo const& lineInfo ) {
+
+        registerTestCase
+            (   new MethodTestCase<C>( method ),
+                className,
+                nameAndDesc,
+                lineInfo );
+    }
+
+    ~AutoReg();
+
+private:
+    AutoReg( AutoReg const& );
+    void operator= ( AutoReg const& );
+};
+
+void registerTestCaseFunction
+    (   TestFunction function,
+        SourceLineInfo const& lineInfo,
+        NameAndDesc const& nameAndDesc );
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ \
+            struct TestName : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+#else
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \
+        static void TestName(); \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ \
+            struct TestCaseName : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        void TestCaseName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+#endif
+
+// #included from: internal/catch_capture.hpp
+#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
+
+// #included from: catch_result_builder.h
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
+
+// #included from: catch_result_type.h
+#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    inline bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    inline bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x01,
+
+        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+        FalseTest = 0x04,           // Prefix expression with !
+        SuppressFail = 0x08         // Failures are reported but do not fail the test
+    }; };
+
+    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.h
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
+
+    struct DecomposedExpression
+    {
+        virtual ~DecomposedExpression() {}
+        virtual bool isBinaryExpression() const {
+            return false;
+        }
+        virtual void reconstructExpression( std::string& dest ) const = 0;
+
+        // Only simple binary comparisons can be decomposed.
+        // If more complex check is required then wrap sub-expressions in parentheses.
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator % ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );
+
+    private:
+        DecomposedExpression& operator = (DecomposedExpression const&);
+    };
+
+    struct AssertionInfo
+    {
+        AssertionInfo();
+        AssertionInfo(  char const * _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        char const * _capturedExpression,
+                        ResultDisposition::Flags _resultDisposition,
+                        char const * _secondArg = "");
+
+        char const * macroName;
+        SourceLineInfo lineInfo;
+        char const * capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+        char const * secondArg;
+    };
+
+    struct AssertionResultData
+    {
+        AssertionResultData() : decomposedExpression( CATCH_NULL )
+                              , resultType( ResultWas::Unknown )
+                              , negated( false )
+                              , parenthesized( false ) {}
+
+        void negate( bool parenthesize ) {
+            negated = !negated;
+            parenthesized = parenthesize;
+            if( resultType == ResultWas::Ok )
+                resultType = ResultWas::ExpressionFailed;
+            else if( resultType == ResultWas::ExpressionFailed )
+                resultType = ResultWas::Ok;
+        }
+
+        std::string const& reconstructExpression() const {
+            if( decomposedExpression != CATCH_NULL ) {
+                decomposedExpression->reconstructExpression( reconstructedExpression );
+                if( parenthesized ) {
+                    reconstructedExpression.insert( 0, 1, '(' );
+                    reconstructedExpression.append( 1, ')' );
+                }
+                if( negated ) {
+                    reconstructedExpression.insert( 0, 1, '!' );
+                }
+                decomposedExpression = CATCH_NULL;
+            }
+            return reconstructedExpression;
+        }
+
+        mutable DecomposedExpression const* decomposedExpression;
+        mutable std::string reconstructedExpression;
+        std::string message;
+        ResultWas::OfType resultType;
+        bool negated;
+        bool parenthesized;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult();
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+        ~AssertionResult();
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+         AssertionResult( AssertionResult const& )              = default;
+         AssertionResult( AssertionResult && )                  = default;
+         AssertionResult& operator = ( AssertionResult const& ) = default;
+         AssertionResult& operator = ( AssertionResult && )     = default;
+#  endif
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        std::string getTestMacroName() const;
+        void discardDecomposedExpression() const;
+        void expandDecomposedExpression() const;
+
+    protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_matchers.hpp
+#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        template<typename ArgT> struct MatchAllOf;
+        template<typename ArgT> struct MatchAnyOf;
+        template<typename ArgT> struct MatchNotOf;
+
+        class MatcherUntypedBase {
+        public:
+            std::string toString() const {
+                if( m_cachedToString.empty() )
+                    m_cachedToString = describe();
+                return m_cachedToString;
+            }
+
+        protected:
+            virtual ~MatcherUntypedBase();
+            virtual std::string describe() const = 0;
+            mutable std::string m_cachedToString;
+        private:
+            MatcherUntypedBase& operator = ( MatcherUntypedBase const& );
+        };
+
+        template<typename ObjectT>
+        struct MatcherMethod {
+            virtual bool match( ObjectT const& arg ) const = 0;
+        };
+        template<typename PtrT>
+        struct MatcherMethod<PtrT*> {
+            virtual bool match( PtrT* arg ) const = 0;
+        };
+
+        template<typename ObjectT, typename ComparatorT = ObjectT>
+        struct MatcherBase : MatcherUntypedBase, MatcherMethod<ObjectT> {
+
+            MatchAllOf<ComparatorT> operator && ( MatcherBase const& other ) const;
+            MatchAnyOf<ComparatorT> operator || ( MatcherBase const& other ) const;
+            MatchNotOf<ComparatorT> operator ! () const;
+        };
+
+        template<typename ArgT>
+        struct MatchAllOf : MatcherBase<ArgT> {
+            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if (!m_matchers[i]->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        description += " and ";
+                    description += m_matchers[i]->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
+                m_matchers.push_back( &other );
+                return *this;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+        template<typename ArgT>
+        struct MatchAnyOf : MatcherBase<ArgT> {
+
+            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if (m_matchers[i]->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        description += " or ";
+                    description += m_matchers[i]->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
+                m_matchers.push_back( &other );
+                return *this;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+
+        template<typename ArgT>
+        struct MatchNotOf : MatcherBase<ArgT> {
+
+            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "not " + m_underlyingMatcher.toString();
+            }
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+        };
+
+        template<typename ObjectT, typename ComparatorT>
+        MatchAllOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator && ( MatcherBase const& other ) const {
+            return MatchAllOf<ComparatorT>() && *this && other;
+        }
+        template<typename ObjectT, typename ComparatorT>
+        MatchAnyOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator || ( MatcherBase const& other ) const {
+            return MatchAnyOf<ComparatorT>() || *this || other;
+        }
+        template<typename ObjectT, typename ComparatorT>
+        MatchNotOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator ! () const {
+            return MatchNotOf<ComparatorT>( *this );
+        }
+
+    } // namespace Impl
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    // - deprecated: prefer ||, && and !
+    template<typename T>
+    Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
+        return Impl::MatchNotOf<T>( underlyingMatcher );
+    }
+    template<typename T>
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+        return Impl::MatchAllOf<T>() && m1 && m2;
+    }
+    template<typename T>
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+        return Impl::MatchAllOf<T>() && m1 && m2 && m3;
+    }
+    template<typename T>
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+        return Impl::MatchAnyOf<T>() || m1 || m2;
+    }
+    template<typename T>
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+        return Impl::MatchAnyOf<T>() || m1 || m2 || m3;
+    }
+
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+namespace Catch {
+
+    struct TestFailureException{};
+
+    template<typename T> class ExpressionLhs;
+
+    struct CopyableStream {
+        CopyableStream() {}
+        CopyableStream( CopyableStream const& other ) {
+            oss << other.oss.str();
+        }
+        CopyableStream& operator=( CopyableStream const& other ) {
+            oss.str(std::string());
+            oss << other.oss.str();
+            return *this;
+        }
+        std::ostringstream oss;
+    };
+
+    class ResultBuilder : public DecomposedExpression {
+    public:
+        ResultBuilder(  char const* macroName,
+                        SourceLineInfo const& lineInfo,
+                        char const* capturedExpression,
+                        ResultDisposition::Flags resultDisposition,
+                        char const* secondArg = "" );
+        ~ResultBuilder();
+
+        template<typename T>
+        ExpressionLhs<T const&> operator <= ( T const& operand );
+        ExpressionLhs<bool> operator <= ( bool value );
+
+        template<typename T>
+        ResultBuilder& operator << ( T const& value ) {
+            stream().oss << value;
+            return *this;
+        }
+
+        ResultBuilder& setResultType( ResultWas::OfType result );
+        ResultBuilder& setResultType( bool result );
+
+        void endExpression( DecomposedExpression const& expr );
+
+        virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE;
+
+        AssertionResult build() const;
+        AssertionResult build( DecomposedExpression const& expr ) const;
+
+        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
+        void captureResult( ResultWas::OfType resultType );
+        void captureExpression();
+        void captureExpectedException( std::string const& expectedMessage );
+        void captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher );
+        void handleResult( AssertionResult const& result );
+        void react();
+        bool shouldDebugBreak() const;
+        bool allowThrows() const;
+
+        template<typename ArgT, typename MatcherT>
+        void captureMatch( ArgT const& arg, MatcherT const& matcher, char const* matcherString );
+
+        void setExceptionGuard();
+        void unsetExceptionGuard();
+
+    private:
+        AssertionInfo m_assertionInfo;
+        AssertionResultData m_data;
+
+        CopyableStream &stream()
+        {
+            if(!m_usedStream)
+            {
+                m_usedStream = true;
+                m_stream().oss.str("");
+            }
+            return m_stream();
+        }
+
+        static CopyableStream &m_stream()
+        {
+            static CopyableStream s;
+            return s;
+        }
+
+        bool m_shouldDebugBreak;
+        bool m_shouldThrow;
+        bool m_guardException;
+        bool m_usedStream;
+    };
+
+} // namespace Catch
+
+// Include after due to circular dependency:
+// #included from: catch_expression_lhs.hpp
+#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
+
+// #included from: catch_evaluate.hpp
+#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#endif
+
+#include <cstddef>
+
+namespace Catch {
+namespace Internal {
+
+    enum Operator {
+        IsEqualTo,
+        IsNotEqualTo,
+        IsLessThan,
+        IsGreaterThan,
+        IsLessThanOrEqualTo,
+        IsGreaterThanOrEqualTo
+    };
+
+    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
+    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
+    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
+    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
+    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
+    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
+    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
+
+    template<typename T>
+    T& opCast(T const& t) { return const_cast<T&>(t); }
+
+// nullptr_t support based on pull request #154 from Konstantin Baumann
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+    // So the compare overloads can be operator agnostic we convey the operator as a template
+    // enum, which is used to specialise an Evaluator for doing the comparison.
+    template<typename T1, typename T2, Operator Op>
+    struct Evaluator{};
+
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs) {
+            return bool( opCast( lhs ) ==  opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsNotEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) != opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) < opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) > opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) >= opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) <= opCast( rhs ) );
+        }
+    };
+
+    template<Operator Op, typename T1, typename T2>
+    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // This level of indirection allows us to specialise for integer types
+    // to avoid signed/ unsigned warnings
+
+    // "base" overload
+    template<Operator Op, typename T1, typename T2>
+    bool compare( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // unsigned X to int
+    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+
+    // unsigned X to long
+    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+
+    // int to unsigned X
+    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+
+    // long to unsigned X
+    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // pointer to long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+    // pointer to int (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+    // long long to unsigned X
+    template<Operator Op> bool compare( long long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // unsigned long long to X
+    template<Operator Op> bool compare( unsigned long long lhs, int rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, char rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+
+    // pointer to long long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+#endif // CATCH_CONFIG_CPP11_LONG_LONG
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    // pointer to nullptr_t (when comparing against nullptr)
+    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
+    }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+} // end of namespace Internal
+} // end of namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// #included from: catch_tostring.h
+#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
+
+#include <sstream>
+#include <iomanip>
+#include <limits>
+#include <vector>
+#include <cstddef>
+
+#ifdef __OBJC__
+// #included from: catch_objc_arc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_TUPLE
+#include <tuple>
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_IS_ENUM
+#include <type_traits>
+#endif
+
+namespace Catch {
+
+// Why we're here.
+template<typename T>
+std::string toString( T const& value );
+
+// Built in overloads
+
+std::string toString( std::string const& value );
+std::string toString( std::wstring const& value );
+std::string toString( const char* const value );
+std::string toString( char* const value );
+std::string toString( const wchar_t* const value );
+std::string toString( wchar_t* const value );
+std::string toString( int value );
+std::string toString( unsigned long value );
+std::string toString( unsigned int value );
+std::string toString( const double value );
+std::string toString( const float value );
+std::string toString( bool value );
+std::string toString( char value );
+std::string toString( signed char value );
+std::string toString( unsigned char value );
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+std::string toString( long long value );
+std::string toString( unsigned long long value );
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t );
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring );
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring );
+    std::string toString( NSObject* const& nsObject );
+#endif
+
+namespace Detail {
+
+    extern const std::string unprintableString;
+
+ #if !defined(CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK)
+    struct BorgType {
+        template<typename T> BorgType( T const& );
+    };
+
+    struct TrueType { char sizer[1]; };
+    struct FalseType { char sizer[2]; };
+
+    TrueType& testStreamable( std::ostream& );
+    FalseType testStreamable( FalseType );
+
+    FalseType operator<<( std::ostream const&, BorgType const& );
+
+    template<typename T>
+    struct IsStreamInsertable {
+        static std::ostream &s;
+        static T  const&t;
+        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
+    };
+#else
+    template<typename T>
+    class IsStreamInsertable {
+        template<typename SS, typename TT>
+        static auto test(int)
+        -> decltype( std::declval<SS&>() << std::declval<TT>(), std::true_type() );
+
+        template<typename, typename>
+        static auto test(...) -> std::false_type;
+
+    public:
+        static const bool value = decltype(test<std::ostream,const T&>(0))::value;
+    };
+#endif
+
+#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
+    template<typename T,
+             bool IsEnum = std::is_enum<T>::value
+             >
+    struct EnumStringMaker
+    {
+        static std::string convert( T const& ) { return unprintableString; }
+    };
+
+    template<typename T>
+    struct EnumStringMaker<T,true>
+    {
+        static std::string convert( T const& v )
+        {
+            return ::Catch::toString(
+                static_cast<typename std::underlying_type<T>::type>(v)
+                );
+        }
+    };
+#endif
+    template<bool C>
+    struct StringMakerBase {
+#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
+        template<typename T>
+        static std::string convert( T const& v )
+        {
+            return EnumStringMaker<T>::convert( v );
+        }
+#else
+        template<typename T>
+        static std::string convert( T const& ) { return unprintableString; }
+#endif
+    };
+
+    template<>
+    struct StringMakerBase<true> {
+        template<typename T>
+        static std::string convert( T const& _value ) {
+            std::ostringstream oss;
+            oss << _value;
+            return oss.str();
+        }
+    };
+
+    std::string rawMemoryToString( const void *object, std::size_t size );
+
+    template<typename T>
+    std::string rawMemoryToString( const T& object ) {
+      return rawMemoryToString( &object, sizeof(object) );
+    }
+
+} // end namespace Detail
+
+template<typename T>
+struct StringMaker :
+    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
+
+template<typename T>
+struct StringMaker<T*> {
+    template<typename U>
+    static std::string convert( U* p ) {
+        if( !p )
+            return "NULL";
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+template<typename R, typename C>
+struct StringMaker<R C::*> {
+    static std::string convert( R C::* p ) {
+        if( !p )
+            return "NULL";
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last );
+}
+
+//template<typename T, typename Allocator>
+//struct StringMaker<std::vector<T, Allocator> > {
+//    static std::string convert( std::vector<T,Allocator> const& v ) {
+//        return Detail::rangeToString( v.begin(), v.end() );
+//    }
+//};
+
+template<typename T, typename Allocator>
+std::string toString( std::vector<T,Allocator> const& v ) {
+    return Detail::rangeToString( v.begin(), v.end() );
+}
+
+#ifdef CATCH_CONFIG_CPP11_TUPLE
+
+// toString for tuples
+namespace TupleDetail {
+  template<
+      typename Tuple,
+      std::size_t N = 0,
+      bool = (N < std::tuple_size<Tuple>::value)
+      >
+  struct ElementPrinter {
+      static void print( const Tuple& tuple, std::ostream& os )
+      {
+          os << ( N ? ", " : " " )
+             << Catch::toString(std::get<N>(tuple));
+          ElementPrinter<Tuple,N+1>::print(tuple,os);
+      }
+  };
+
+  template<
+      typename Tuple,
+      std::size_t N
+      >
+  struct ElementPrinter<Tuple,N,false> {
+      static void print( const Tuple&, std::ostream& ) {}
+  };
+
+}
+
+template<typename ...Types>
+struct StringMaker<std::tuple<Types...>> {
+
+    static std::string convert( const std::tuple<Types...>& tuple )
+    {
+        std::ostringstream os;
+        os << '{';
+        TupleDetail::ElementPrinter<std::tuple<Types...>>::print( tuple, os );
+        os << " }";
+        return os.str();
+    }
+};
+#endif // CATCH_CONFIG_CPP11_TUPLE
+
+namespace Detail {
+    template<typename T>
+    std::string makeString( T const& value ) {
+        return StringMaker<T>::convert( value );
+    }
+} // end namespace Detail
+
+/// \brief converts any type to a string
+///
+/// The default template forwards on to ostringstream - except when an
+/// ostringstream overload does not exist - in which case it attempts to detect
+/// that and writes {?}.
+/// Overload (not specialise) this template for custom typs that you don't want
+/// to provide an ostream overload for.
+template<typename T>
+std::string toString( T const& value ) {
+    return StringMaker<T>::convert( value );
+}
+
+    namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last ) {
+        std::ostringstream oss;
+        oss << "{ ";
+        if( first != last ) {
+            oss << Catch::toString( *first );
+            for( ++first ; first != last ; ++first )
+                oss << ", " << Catch::toString( *first );
+        }
+        oss << " }";
+        return oss.str();
+    }
+}
+
+} // end namespace Catch
+
+namespace Catch {
+
+template<typename LhsT, Internal::Operator Op, typename RhsT>
+class BinaryExpression;
+
+template<typename ArgT, typename MatcherT>
+class MatchExpression;
+
+// Wraps the LHS of an expression and overloads comparison operators
+// for also capturing those and RHS (if any)
+template<typename T>
+class ExpressionLhs : public DecomposedExpression {
+public:
+    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ), m_truthy(false) {}
+
+    ExpressionLhs& operator = ( const ExpressionLhs& );
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsEqualTo, RhsT const&>
+    operator == ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsNotEqualTo, RhsT const&>
+    operator != ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsLessThan, RhsT const&>
+    operator < ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThan>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsGreaterThan, RhsT const&>
+    operator > ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThan>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsLessThanOrEqualTo, RhsT const&>
+    operator <= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsGreaterThanOrEqualTo, RhsT const&>
+    operator >= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
+    }
+
+    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    void endExpression() {
+        m_truthy = m_lhs ? true : false;
+        m_rb
+            .setResultType( m_truthy )
+            .endExpression( *this );
+    }
+
+    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
+        dest = Catch::toString( m_lhs );
+    }
+
+private:
+    template<Internal::Operator Op, typename RhsT>
+    BinaryExpression<T, Op, RhsT&> captureExpression( RhsT& rhs ) const {
+        return BinaryExpression<T, Op, RhsT&>( m_rb, m_lhs, rhs );
+    }
+
+    template<Internal::Operator Op>
+    BinaryExpression<T, Op, bool> captureExpression( bool rhs ) const {
+        return BinaryExpression<T, Op, bool>( m_rb, m_lhs, rhs );
+    }
+
+private:
+    ResultBuilder& m_rb;
+    T m_lhs;
+    bool m_truthy;
+};
+
+template<typename LhsT, Internal::Operator Op, typename RhsT>
+class BinaryExpression : public DecomposedExpression {
+public:
+    BinaryExpression( ResultBuilder& rb, LhsT lhs, RhsT rhs )
+        : m_rb( rb ), m_lhs( lhs ), m_rhs( rhs ) {}
+
+    BinaryExpression& operator = ( BinaryExpression& );
+
+    void endExpression() const {
+        m_rb
+            .setResultType( Internal::compare<Op>( m_lhs, m_rhs ) )
+            .endExpression( *this );
+    }
+
+    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
+        return true;
+    }
+
+    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
+        std::string lhs = Catch::toString( m_lhs );
+        std::string rhs = Catch::toString( m_rhs );
+        char delim = lhs.size() + rhs.size() < 40 &&
+                     lhs.find('\n') == std::string::npos &&
+                     rhs.find('\n') == std::string::npos ? ' ' : '\n';
+        dest.reserve( 7 + lhs.size() + rhs.size() );
+                   // 2 for spaces around operator
+                   // 2 for operator
+                   // 2 for parentheses (conditionally added later)
+                   // 1 for negation (conditionally added later)
+        dest = lhs;
+        dest += delim;
+        dest += Internal::OperatorTraits<Op>::getName();
+        dest += delim;
+        dest += rhs;
+    }
+
+private:
+    ResultBuilder& m_rb;
+    LhsT m_lhs;
+    RhsT m_rhs;
+};
+
+template<typename ArgT, typename MatcherT>
+class MatchExpression : public DecomposedExpression {
+public:
+    MatchExpression( ArgT arg, MatcherT matcher, char const* matcherString )
+        : m_arg( arg ), m_matcher( matcher ), m_matcherString( matcherString ) {}
+
+    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
+        return true;
+    }
+
+    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
+        std::string matcherAsString = m_matcher.toString();
+        dest = Catch::toString( m_arg );
+        dest += ' ';
+        if( matcherAsString == Detail::unprintableString )
+            dest += m_matcherString;
+        else
+            dest += matcherAsString;
+    }
+
+private:
+    ArgT m_arg;
+    MatcherT m_matcher;
+    char const* m_matcherString;
+};
+
+} // end namespace Catch
+
+
+namespace Catch {
+
+    template<typename T>
+    ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
+        return ExpressionLhs<T const&>( *this, operand );
+    }
+
+    inline ExpressionLhs<bool> ResultBuilder::operator <= ( bool value ) {
+        return ExpressionLhs<bool>( *this, value );
+    }
+
+    template<typename ArgT, typename MatcherT>
+    void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
+                                             char const* matcherString ) {
+        MatchExpression<ArgT const&, MatcherT const&> expr( arg, matcher, matcherString );
+        setResultType( matcher.match( arg ) );
+        endExpression( expr );
+    }
+
+} // namespace Catch
+
+// #included from: catch_message.h
+#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        std::string macroName;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        std::string message;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const {
+            return sequence == other.sequence;
+        }
+        bool operator < ( MessageInfo const& other ) const {
+            return sequence < other.sequence;
+        }
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageBuilder {
+        MessageBuilder( std::string const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type )
+        : m_info( macroName, lineInfo, type )
+        {}
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+        std::ostringstream m_stream;
+    };
+
+    class ScopedMessage {
+    public:
+        ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage const& other );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_capture.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    class ScopedMessageBuilder;
+    struct Counts;
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual void assertionEnded( AssertionResult const& result ) = 0;
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+
+        virtual void exceptionEarlyReported() = 0;
+
+        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+        virtual void assertionRun() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// #included from: catch_debugger.h
+#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
+
+// #included from: catch_platform.h
+#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
+
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#  define CATCH_PLATFORM_MAC
+#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
+#  define CATCH_PLATFORM_IPHONE
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#  define CATCH_PLATFORM_WINDOWS
+#  if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
+#    define CATCH_DEFINES_NOMINMAX
+#  endif
+#  if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
+#    define CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#  endif
+#endif
+
+#include <string>
+
+namespace Catch{
+
+    bool isDebuggerActive();
+    void writeToDebugConsole( std::string const& text );
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    // The following code snippet based on:
+    // http://cocoawithlove.com/2008/03/break-into-debugger.html
+    #if defined(__ppc64__) || defined(__ppc__)
+        #define CATCH_TRAP() \
+                __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+                : : : "memory","r0","r3","r4" ) /* NOLINT */
+    #else
+        #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifdef CATCH_TRAP
+    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); }
+#else
+    #define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
+#endif
+
+// #included from: catch_interfaces_runner.h
+#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
+
+namespace Catch {
+    class TestCase;
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+# define CATCH_INTERNAL_STRINGIFY(expr) #expr
+#else
+# define CATCH_INTERNAL_STRINGIFY(expr) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+///////////////////////////////////////////////////////////////////////////////
+// We can speedup compilation significantly by breaking into debugger lower in
+// the callstack, because then we don't have to expand CATCH_BREAK_INTO_DEBUGGER
+// macro in each assertion
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    resultBuilder.react();
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+// This can potentially cause false negative, if the test code catches
+// the exception before it propagates back up to the runner.
+#define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+        ( __catchResult <= expr ).endExpression(); \
+        CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+
+#define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+#else
+///////////////////////////////////////////////////////////////////////////////
+// In the event of a failure works out if the debugger needs to be invoked
+// and/or an exception thrown and takes appropriate action.
+// This needs to be done as a macro so the debugger will stop in the user
+// source code rather than in Catch library code
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
+    resultBuilder.react();
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        try { \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            ( __catchResult <= expr ).endExpression(); \
+            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
+    if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
+    if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        try { \
+            static_cast<void>(expr); \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( ... ) { \
+                __catchResult.captureExpectedException( matcher ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( exceptionType ) { \
+                __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            } \
+            catch( ... ) { \
+                __catchResult.useActiveException( resultDisposition ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#else
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, log ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << log + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        try { \
+            __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        } catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+// #included from: internal/catch_section.h
+#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
+
+// #included from: catch_section_info.h
+#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
+
+// #included from: catch_totals.hpp
+#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}
+
+        Counts operator - ( Counts const& other ) const {
+            Counts diff;
+            diff.passed = passed - other.passed;
+            diff.failed = failed - other.failed;
+            diff.failedButOk = failedButOk - other.failedButOk;
+            return diff;
+        }
+        Counts& operator += ( Counts const& other ) {
+            passed += other.passed;
+            failed += other.failed;
+            failedButOk += other.failedButOk;
+            return *this;
+        }
+
+        std::size_t total() const {
+            return passed + failed + failedButOk;
+        }
+        bool allPassed() const {
+            return failed == 0 && failedButOk == 0;
+        }
+        bool allOk() const {
+            return failed == 0;
+        }
+
+        std::size_t passed;
+        std::size_t failed;
+        std::size_t failedButOk;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const {
+            Totals diff;
+            diff.assertions = assertions - other.assertions;
+            diff.testCases = testCases - other.testCases;
+            return diff;
+        }
+
+        Totals delta( Totals const& prevTotals ) const {
+            Totals diff = *this - prevTotals;
+            if( diff.assertions.failed > 0 )
+                ++diff.testCases.failed;
+            else if( diff.assertions.failedButOk > 0 )
+                ++diff.testCases.failedButOk;
+            else
+                ++diff.testCases.passed;
+            return diff;
+        }
+
+        Totals& operator += ( Totals const& other ) {
+            assertions += other.assertions;
+            testCases += other.testCases;
+            return *this;
+        }
+
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& _description = std::string() );
+
+        std::string name;
+        std::string description;
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds )
+        : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
+        {}
+
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_timer.h
+#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
+
+#ifdef _MSC_VER
+
+namespace Catch {
+    typedef unsigned long long UInt64;
+}
+#else
+#include <stdint.h>
+namespace Catch {
+    typedef uint64_t UInt64;
+}
+#endif
+
+namespace Catch {
+    class Timer {
+    public:
+        Timer() : m_ticks( 0 ) {}
+        void start();
+        unsigned int getElapsedMicroseconds() const;
+        unsigned int getElapsedMilliseconds() const;
+        double getElapsedSeconds() const;
+
+    private:
+        UInt64 m_ticks;
+    };
+
+} // namespace Catch
+
+#include <string>
+
+namespace Catch {
+
+    class Section : NonCopyable {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_SECTION( ... ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
+#else
+    #define INTERNAL_CATCH_SECTION( name, desc ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
+#endif
+
+// #included from: internal/catch_generators.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
+
+#include <vector>
+#include <string>
+#include <stdlib.h>
+
+namespace Catch {
+
+template<typename T>
+struct IGenerator {
+    virtual ~IGenerator() {}
+    virtual T getValue( std::size_t index ) const = 0;
+    virtual std::size_t size () const = 0;
+};
+
+template<typename T>
+class BetweenGenerator : public IGenerator<T> {
+public:
+    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
+
+    virtual T getValue( std::size_t index ) const {
+        return m_from+static_cast<int>( index );
+    }
+
+    virtual std::size_t size() const {
+        return static_cast<std::size_t>( 1+m_to-m_from );
+    }
+
+private:
+
+    T m_from;
+    T m_to;
+};
+
+template<typename T>
+class ValuesGenerator : public IGenerator<T> {
+public:
+    ValuesGenerator(){}
+
+    void add( T value ) {
+        m_values.push_back( value );
+    }
+
+    virtual T getValue( std::size_t index ) const {
+        return m_values[index];
+    }
+
+    virtual std::size_t size() const {
+        return m_values.size();
+    }
+
+private:
+    std::vector<T> m_values;
+};
+
+template<typename T>
+class CompositeGenerator {
+public:
+    CompositeGenerator() : m_totalSize( 0 ) {}
+
+    // *** Move semantics, similar to auto_ptr ***
+    CompositeGenerator( CompositeGenerator& other )
+    :   m_fileInfo( other.m_fileInfo ),
+        m_totalSize( 0 )
+    {
+        move( other );
+    }
+
+    CompositeGenerator& setFileInfo( const char* fileInfo ) {
+        m_fileInfo = fileInfo;
+        return *this;
+    }
+
+    ~CompositeGenerator() {
+        deleteAll( m_composed );
+    }
+
+    operator T () const {
+        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );
+
+        typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
+        typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
+        for( size_t index = 0; it != itEnd; ++it )
+        {
+            const IGenerator<T>* generator = *it;
+            if( overallIndex >= index && overallIndex < index + generator->size() )
+            {
+                return generator->getValue( overallIndex-index );
+            }
+            index += generator->size();
+        }
+        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
+        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
+    }
+
+    void add( const IGenerator<T>* generator ) {
+        m_totalSize += generator->size();
+        m_composed.push_back( generator );
+    }
+
+    CompositeGenerator& then( CompositeGenerator& other ) {
+        move( other );
+        return *this;
+    }
+
+    CompositeGenerator& then( T value ) {
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( value );
+        add( valuesGen );
+        return *this;
+    }
+
+private:
+
+    void move( CompositeGenerator& other ) {
+        m_composed.insert( m_composed.end(), other.m_composed.begin(), other.m_composed.end() );
+        m_totalSize += other.m_totalSize;
+        other.m_composed.clear();
+    }
+
+    std::vector<const IGenerator<T>*> m_composed;
+    std::string m_fileInfo;
+    size_t m_totalSize;
+};
+
+namespace Generators
+{
+    template<typename T>
+    CompositeGenerator<T> between( T from, T to ) {
+        CompositeGenerator<T> generators;
+        generators.add( new BetweenGenerator<T>( from, to ) );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3 ){
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3, T val4 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        valuesGen->add( val4 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+} // end namespace Generators
+
+using namespace Generators;
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_LINESTR2( line ) #line
+#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )
+
+#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )
+
+// #included from: internal/catch_interfaces_exception.h
+#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
+
+#include <string>
+#include <vector>
+
+// #included from: catch_interfaces_registry_hub.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+    struct ITagAliasRegistry;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+
+        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) = 0;
+        virtual void registerListener( Ptr<IReporterFactory> const& factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+    };
+
+    IRegistryHub& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+namespace Catch {
+
+    typedef std::string(*exceptionTranslateFunction)();
+
+    struct IExceptionTranslator;
+    typedef std::vector<const IExceptionTranslator*> ExceptionTranslators;
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const CATCH_OVERRIDE {
+                try {
+                    if( it == itEnd )
+                        throw;
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); }\
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// #included from: internal/catch_approx.hpp
+#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+
+#include <cmath>
+#include <limits>
+
+#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+#include <type_traits>
+#endif
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    public:
+        explicit Approx ( double value )
+        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+            m_margin( 0.0 ),
+            m_scale( 1.0 ),
+            m_value( value )
+        {}
+
+        static Approx custom() {
+            return Approx( 0 );
+        }
+
+#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T value ) {
+            Approx approx( static_cast<double>(value) );
+            approx.epsilon( m_epsilon );
+            approx.margin( m_margin );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T value ): Approx(static_cast<double>(value))
+        {}
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            auto lhs_v = double(lhs);
+            bool relativeOK = std::fabs(lhs_v - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (std::max)(std::fabs(lhs_v), std::fabs(rhs.m_value)));
+            if (relativeOK) {
+                return true;
+            }
+
+            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( T lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( Approx const& lhs, T rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( T lhs, Approx const& rhs ) {
+            return double(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value < double(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( T lhs, Approx const& rhs ) {
+            return double(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value > double(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T newEpsilon ) {
+            m_epsilon = double(newEpsilon);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T newMargin ) {
+            m_margin = double(newMargin);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T newScale ) {
+            m_scale = double(newScale);
+            return *this;
+        }
+
+#else
+
+        Approx operator()( double value ) {
+            Approx approx( value );
+            approx.epsilon( m_epsilon );
+            approx.margin( m_margin );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+        friend bool operator == ( double lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            bool relativeOK = std::fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( std::fabs(lhs), std::fabs(rhs.m_value) ) );
+            if (relativeOK) {
+                return true;
+            }
+            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
+        }
+
+        friend bool operator == ( Approx const& lhs, double rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        friend bool operator != ( double lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        friend bool operator != ( Approx const& lhs, double rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        friend bool operator <= ( double lhs, Approx const& rhs ) {
+            return lhs < rhs.m_value || lhs == rhs;
+        }
+
+        friend bool operator <= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value < rhs || lhs == rhs;
+        }
+
+        friend bool operator >= ( double lhs, Approx const& rhs ) {
+            return lhs > rhs.m_value || lhs == rhs;
+        }
+
+        friend bool operator >= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value > rhs || lhs == rhs;
+        }
+
+        Approx& epsilon( double newEpsilon ) {
+            m_epsilon = newEpsilon;
+            return *this;
+        }
+
+        Approx& margin( double newMargin ) {
+            m_margin = newMargin;
+            return *this;
+        }
+
+        Approx& scale( double newScale ) {
+            m_scale = newScale;
+            return *this;
+        }
+#endif
+
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << "Approx( " << Catch::toString( m_value ) << " )";
+            return oss.str();
+        }
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+}
+
+template<>
+inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
+    return value.toString();
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_matchers_string.h
+#define TWOBLUECUBES_CATCH_MATCHERS_STRING_H_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        struct CasedString
+        {
+            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+            std::string adjustString( std::string const& str ) const;
+            std::string caseSensitivitySuffix() const;
+
+            CaseSensitive::Choice m_caseSensitivity;
+            std::string m_str;
+        };
+
+        struct StringMatcherBase : MatcherBase<std::string> {
+            StringMatcherBase( std::string const& operation, CasedString const& comparator );
+            virtual std::string describe() const CATCH_OVERRIDE;
+
+            CasedString m_comparator;
+            std::string m_operation;
+        };
+
+        struct EqualsMatcher : StringMatcherBase {
+            EqualsMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct ContainsMatcher : StringMatcherBase {
+            ContainsMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct StartsWithMatcher : StringMatcherBase {
+            StartsWithMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct EndsWithMatcher : StringMatcherBase {
+            EndsWithMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+
+    } // namespace StdString
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+// #included from: internal/catch_matchers_vector.h
+#define TWOBLUECUBES_CATCH_MATCHERS_VECTOR_H_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Vector {
+
+        template<typename T>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T>, T> {
+
+            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+
+            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+                return std::find(v.begin(), v.end(), m_comparator) != v.end();
+            }
+
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "Contains: " + Catch::toString( m_comparator );
+            }
+
+            T const& m_comparator;
+        };
+
+        template<typename T>
+        struct ContainsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
+
+            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+                // !TBD: see note in EqualsMatcher
+                if (m_comparator.size() > v.size())
+                    return false;
+                for (size_t i = 0; i < m_comparator.size(); ++i)
+                    if (std::find(v.begin(), v.end(), m_comparator[i]) == v.end())
+                        return false;
+                return true;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "Contains: " + Catch::toString( m_comparator );
+            }
+
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct EqualsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
+
+            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+                // !TBD: This currently works if all elements can be compared using !=
+                // - a more general approach would be via a compare template that defaults
+                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // - then just call that directly
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != v[i])
+                        return false;
+                return true;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "Equals: " + Catch::toString( m_comparator );
+            }
+            std::vector<T> const& m_comparator;
+        };
+
+    } // namespace Vector
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    template<typename T>
+    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
+        return Vector::ContainsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
+        return Vector::EqualsMatcher<T>( comparator );
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// #included from: internal/catch_interfaces_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+// #included from: catch_tag_alias.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias( std::string const& _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
+// #included from: catch_option.hpp
+#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( CATCH_NULL ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : CATCH_NULL )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = CATCH_NULL;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != CATCH_NULL; }
+        bool none() const { return nullableValue == CATCH_NULL; }
+
+        bool operator !() const { return nullableValue == CATCH_NULL; }
+        operator SafeBool::type() const {
+            return SafeBool::makeSafe( some() );
+        }
+
+    private:
+        T *nullableValue;
+        union {
+            char storage[sizeof(T)];
+
+            // These are here to force alignment for the storage
+            long double dummy1;
+            void (*dummy2)();
+            long double dummy3;
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+            long long dummy4;
+#endif
+        };
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// #included from: internal/catch_test_case_info.h
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
+
+#include <string>
+#include <set>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestCase;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::set<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        TestCaseInfo( TestCaseInfo const& other );
+
+        friend void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::set<std::string> tags;
+        std::set<std::string> lcaseTags;
+        std::string tagsAsString;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestCase* testCase, TestCaseInfo const& info );
+        TestCase( TestCase const& other );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        void swap( TestCase& other );
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+        TestCase& operator = ( TestCase const& other );
+
+    private:
+        Ptr<ITestCase> test;
+    };
+
+    TestCase makeTestCase(  ITestCase* testCase,
+                            std::string const& className,
+                            std::string const& name,
+                            std::string const& description,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+
+#ifdef __OBJC__
+// #included from: internal/catch_objc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public SharedImpl<ITestCase> {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline size_t registerTestMethods() {
+        size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( CATCH_NULL, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                virtual bool match( NSString* arg ) const CATCH_OVERRIDE {
+                    return false;
+                }
+
+                NSString* m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const CATCH_OVERRIDE {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "equals string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "contains string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "starts with: " + Catch::toString( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "ends with: " + Catch::toString( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_TEST_CASE( name, desc )\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
+{\
+return @ name; \
+}\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
+{ \
+return @ desc; \
+} \
+-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
+
+#endif
+
+#ifdef CATCH_IMPL
+
+// !TBD: Move the leak detector code into a separate header
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+class LeakDetector {
+public:
+    LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+};
+#else
+class LeakDetector {};
+#endif
+
+LeakDetector leakDetector;
+
+// #included from: internal/catch_impl.hpp
+#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
+
+// Collect all the implementation files together here
+// These are the equivalent of what would usually be cpp files
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// #included from: ../catch_session.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
+
+// #included from: internal/catch_commandline.hpp
+#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
+
+// #included from: catch_config.hpp
+#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
+
+// #included from: catch_test_spec_parser.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_test_spec.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_wildcard_pattern.hpp
+#define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+#include <stdexcept>
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_wildcard( NoWildcard ),
+            m_pattern( adjustCase( pattern ) )
+        {
+            if( startsWith( m_pattern, '*' ) ) {
+                m_pattern = m_pattern.substr( 1 );
+                m_wildcard = WildcardAtStart;
+            }
+            if( endsWith( m_pattern, '*' ) ) {
+                m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+                m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+            }
+        }
+        virtual ~WildcardPattern();
+        virtual bool matches( std::string const& str ) const {
+            switch( m_wildcard ) {
+                case NoWildcard:
+                    return m_pattern == adjustCase( str );
+                case WildcardAtStart:
+                    return endsWith( adjustCase( str ), m_pattern );
+                case WildcardAtEnd:
+                    return startsWith( adjustCase( str ), m_pattern );
+                case WildcardAtBothEnds:
+                    return contains( adjustCase( str ), m_pattern );
+            }
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+            throw std::logic_error( "Unknown enum" );
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+        }
+    private:
+        std::string adjustCase( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
+        }
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard;
+        std::string m_pattern;
+    };
+}
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec {
+        struct Pattern : SharedImpl<> {
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+        };
+        class NamePattern : public Pattern {
+        public:
+            NamePattern( std::string const& name )
+            : m_wildcardPattern( toLower( name ), CaseSensitive::No )
+            {}
+            virtual ~NamePattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                return m_wildcardPattern.matches( toLower( testCase.name ) );
+            }
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
+            virtual ~TagPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
+            }
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            ExcludedPattern( Ptr<Pattern> const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
+            virtual ~ExcludedPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
+        private:
+            Ptr<Pattern> m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<Ptr<Pattern> > m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const {
+                // All patterns in a filter must match for the filter to be a match
+                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) {
+                    if( !(*it)->matches( testCase ) )
+                        return false;
+                }
+                return true;
+            }
+        };
+
+    public:
+        bool hasFilters() const {
+            return !m_filters.empty();
+        }
+        bool matches( TestCaseInfo const& testCase ) const {
+            // A TestSpec matches if any filter matches
+            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
+                if( it->matches( testCase ) )
+                    return true;
+            return false;
+        }
+
+    private:
+        std::vector<Filter> m_filters;
+
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode;
+        bool m_exclusion;
+        std::size_t m_start, m_pos;
+        std::string m_arg;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases ) :m_mode(None), m_exclusion(false), m_start(0), m_pos(0), m_tagAliases( &tagAliases ) {}
+
+        TestSpecParser& parse( std::string const& arg ) {
+            m_mode = None;
+            m_exclusion = false;
+            m_start = std::string::npos;
+            m_arg = m_tagAliases->expandAliases( arg );
+            m_escapeChars.clear();
+            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+                visitChar( m_arg[m_pos] );
+            if( m_mode == Name )
+                addPattern<TestSpec::NamePattern>();
+            return *this;
+        }
+        TestSpec testSpec() {
+            addFilter();
+            return m_testSpec;
+        }
+    private:
+        void visitChar( char c ) {
+            if( m_mode == None ) {
+                switch( c ) {
+                case ' ': return;
+                case '~': m_exclusion = true; return;
+                case '[': return startNewMode( Tag, ++m_pos );
+                case '"': return startNewMode( QuotedName, ++m_pos );
+                case '\\': return escape();
+                default: startNewMode( Name, m_pos ); break;
+                }
+            }
+            if( m_mode == Name ) {
+                if( c == ',' ) {
+                    addPattern<TestSpec::NamePattern>();
+                    addFilter();
+                }
+                else if( c == '[' ) {
+                    if( subString() == "exclude:" )
+                        m_exclusion = true;
+                    else
+                        addPattern<TestSpec::NamePattern>();
+                    startNewMode( Tag, ++m_pos );
+                }
+                else if( c == '\\' )
+                    escape();
+            }
+            else if( m_mode == EscapedName )
+                m_mode = Name;
+            else if( m_mode == QuotedName && c == '"' )
+                addPattern<TestSpec::NamePattern>();
+            else if( m_mode == Tag && c == ']' )
+                addPattern<TestSpec::TagPattern>();
+        }
+        void startNewMode( Mode mode, std::size_t start ) {
+            m_mode = mode;
+            m_start = start;
+        }
+        void escape() {
+            if( m_mode == None )
+                m_start = m_pos;
+            m_mode = EscapedName;
+            m_escapeChars.push_back( m_pos );
+        }
+        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
+        template<typename T>
+        void addPattern() {
+            std::string token = subString();
+            for( size_t i = 0; i < m_escapeChars.size(); ++i )
+                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
+            m_escapeChars.clear();
+            if( startsWith( token, "exclude:" ) ) {
+                m_exclusion = true;
+                token = token.substr( 8 );
+            }
+            if( !token.empty() ) {
+                Ptr<TestSpec::Pattern> pattern = new T( token );
+                if( m_exclusion )
+                    pattern = new TestSpec::ExcludedPattern( pattern );
+                m_currentFilter.m_patterns.push_back( pattern );
+            }
+            m_exclusion = false;
+            m_mode = None;
+        }
+        void addFilter() {
+            if( !m_currentFilter.m_patterns.empty() ) {
+                m_testSpec.m_filters.push_back( m_currentFilter );
+                m_currentFilter = TestSpec::Filter();
+            }
+        }
+    };
+    inline TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// #included from: catch_interfaces_config.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct Verbosity { enum Level {
+        NoOutput = 0,
+        Quiet,
+        Normal
+    }; };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : IShared {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+
+    };
+}
+
+// #included from: catch_stream.h
+#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
+
+// #included from: catch_streambuf.h
+#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
+
+#include <streambuf>
+
+namespace Catch {
+
+    class StreamBufBase : public std::streambuf {
+    public:
+        virtual ~StreamBufBase() CATCH_NOEXCEPT;
+    };
+}
+
+#include <streambuf>
+#include <ostream>
+#include <fstream>
+#include <memory>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+    struct IStream {
+        virtual ~IStream() CATCH_NOEXCEPT;
+        virtual std::ostream& stream() const = 0;
+    };
+
+    class FileStream : public IStream {
+        mutable std::ofstream m_ofs;
+    public:
+        FileStream( std::string const& filename );
+        virtual ~FileStream() CATCH_NOEXCEPT;
+    public: // IStream
+        virtual std::ostream& stream() const CATCH_OVERRIDE;
+    };
+
+    class CoutStream : public IStream {
+        mutable std::ostream m_os;
+    public:
+        CoutStream();
+        virtual ~CoutStream() CATCH_NOEXCEPT;
+
+    public: // IStream
+        virtual std::ostream& stream() const CATCH_OVERRIDE;
+    };
+
+    class DebugOutStream : public IStream {
+        CATCH_AUTO_PTR( StreamBufBase ) m_streamBuf;
+        mutable std::ostream m_os;
+    public:
+        DebugOutStream();
+        virtual ~DebugOutStream() CATCH_NOEXCEPT;
+
+    public: // IStream
+        virtual std::ostream& stream() const CATCH_OVERRIDE;
+    };
+}
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <stdexcept>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct ConfigData {
+
+        ConfigData()
+        :   listTests( false ),
+            listTags( false ),
+            listReporters( false ),
+            listTestNamesOnly( false ),
+            listExtraInfo( false ),
+            showSuccessfulTests( false ),
+            shouldDebugBreak( false ),
+            noThrow( false ),
+            showHelp( false ),
+            showInvisibles( false ),
+            filenamesAsTags( false ),
+            libIdentify( false ),
+            abortAfter( -1 ),
+            rngSeed( 0 ),
+            verbosity( Verbosity::Normal ),
+            warnings( WarnAbout::Nothing ),
+            showDurations( ShowDurations::DefaultForReporter ),
+            runOrder( RunTests::InDeclarationOrder ),
+            useColour( UseColour::Auto ),
+            waitForKeypress( WaitForKeypress::Never )
+        {}
+
+        bool listTests;
+        bool listTags;
+        bool listReporters;
+        bool listTestNamesOnly;
+        bool listExtraInfo;
+
+        bool showSuccessfulTests;
+        bool shouldDebugBreak;
+        bool noThrow;
+        bool showHelp;
+        bool showInvisibles;
+        bool filenamesAsTags;
+        bool libIdentify;
+
+        int abortAfter;
+        unsigned int rngSeed;
+
+        Verbosity::Level verbosity;
+        WarnAbout::What warnings;
+        ShowDurations::OrNot showDurations;
+        RunTests::InWhatOrder runOrder;
+        UseColour::YesOrNo useColour;
+        WaitForKeypress::When waitForKeypress;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+
+        std::vector<std::string> reporterNames;
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public SharedImpl<IConfig> {
+    private:
+        Config( Config const& other );
+        Config& operator = ( Config const& other );
+        virtual void dummy();
+    public:
+
+        Config()
+        {}
+
+        Config( ConfigData const& data )
+        :   m_data( data ),
+            m_stream( openStream() )
+        {
+            if( !data.testsOrTags.empty() ) {
+                TestSpecParser parser( ITagAliasRegistry::get() );
+                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
+                    parser.parse( data.testsOrTags[i] );
+                m_testSpec = parser.testSpec();
+            }
+        }
+
+        virtual ~Config() {}
+
+        std::string const& getFilename() const {
+            return m_data.outputFilename ;
+        }
+
+        bool listTests() const { return m_data.listTests; }
+        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
+        bool listTags() const { return m_data.listTags; }
+        bool listReporters() const { return m_data.listReporters; }
+        bool listExtraInfo() const { return m_data.listExtraInfo; }
+
+        std::string getProcessName() const { return m_data.processName; }
+
+        std::vector<std::string> const& getReporterNames() const { return m_data.reporterNames; }
+        std::vector<std::string> const& getSectionsToRun() const CATCH_OVERRIDE { return m_data.sectionsToRun; }
+
+        virtual TestSpec const& testSpec() const CATCH_OVERRIDE { return m_testSpec; }
+
+        bool showHelp() const { return m_data.showHelp; }
+
+        // IConfig interface
+        virtual bool allowThrows() const CATCH_OVERRIDE                 { return !m_data.noThrow; }
+        virtual std::ostream& stream() const CATCH_OVERRIDE             { return m_stream->stream(); }
+        virtual std::string name() const CATCH_OVERRIDE                 { return m_data.name.empty() ? m_data.processName : m_data.name; }
+        virtual bool includeSuccessfulResults() const CATCH_OVERRIDE    { return m_data.showSuccessfulTests; }
+        virtual bool warnAboutMissingAssertions() const CATCH_OVERRIDE  { return m_data.warnings & WarnAbout::NoAssertions; }
+        virtual ShowDurations::OrNot showDurations() const CATCH_OVERRIDE { return m_data.showDurations; }
+        virtual RunTests::InWhatOrder runOrder() const CATCH_OVERRIDE   { return m_data.runOrder; }
+        virtual unsigned int rngSeed() const CATCH_OVERRIDE             { return m_data.rngSeed; }
+        virtual UseColour::YesOrNo useColour() const CATCH_OVERRIDE     { return m_data.useColour; }
+        virtual bool shouldDebugBreak() const CATCH_OVERRIDE { return m_data.shouldDebugBreak; }
+        virtual int abortAfter() const CATCH_OVERRIDE { return m_data.abortAfter; }
+        virtual bool showInvisibles() const CATCH_OVERRIDE { return m_data.showInvisibles; }
+
+    private:
+
+        IStream const* openStream() {
+            if( m_data.outputFilename.empty() )
+                return new CoutStream();
+            else if( m_data.outputFilename[0] == '%' ) {
+                if( m_data.outputFilename == "%debug" )
+                    return new DebugOutStream();
+                else
+                    throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename );
+            }
+            else
+                return new FileStream( m_data.outputFilename );
+        }
+        ConfigData m_data;
+
+        CATCH_AUTO_PTR( IStream const ) m_stream;
+        TestSpec m_testSpec;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_clara.h
+#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
+#undef CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+// Declare Clara inside the Catch namespace
+#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
+// #included from: ../external/clara.h
+
+// Version 0.0.2.4
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
+
+#ifndef STITCH_CLARA_OPEN_NAMESPACE
+#define TWOBLUECUBES_CLARA_H_INCLUDED
+#define STITCH_CLARA_OPEN_NAMESPACE
+#define STITCH_CLARA_CLOSE_NAMESPACE
+#else
+#define STITCH_CLARA_CLOSE_NAMESPACE }
+#endif
+
+#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
+
+// ----------- #included from tbc_text_format.h -----------
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
+#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+#define TBC_TEXT_FORMAT_H_INCLUDED
+#endif
+
+#include <string>
+#include <vector>
+#include <sstream>
+#include <algorithm>
+#include <cctype>
+
+// Use optional outer namespace
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 ),
+            tabChar( '\t' )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+        char tabChar;               // If this char is seen the indent is changed to current pos
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            std::string wrappableChars = " [({.,/|\\-";
+            std::size_t indent = _attr.initialIndent != std::string::npos
+                ? _attr.initialIndent
+                : _attr.indent;
+            std::string remainder = _str;
+
+            while( !remainder.empty() ) {
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+                std::size_t tabPos = std::string::npos;
+                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
+                std::size_t pos = remainder.find_first_of( '\n' );
+                if( pos <= width ) {
+                    width = pos;
+                }
+                pos = remainder.find_last_of( _attr.tabChar, width );
+                if( pos != std::string::npos ) {
+                    tabPos = pos;
+                    if( remainder[width] == '\n' )
+                        width--;
+                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
+                }
+
+                if( width == remainder.size() ) {
+                    spliceLine( indent, remainder, width );
+                }
+                else if( remainder[width] == '\n' ) {
+                    spliceLine( indent, remainder, width );
+                    if( width <= 1 || remainder.size() != 1 )
+                        remainder = remainder.substr( 1 );
+                    indent = _attr.indent;
+                }
+                else {
+                    pos = remainder.find_last_of( wrappableChars, width );
+                    if( pos != std::string::npos && pos > 0 ) {
+                        spliceLine( indent, remainder, pos );
+                        if( remainder[0] == ' ' )
+                            remainder = remainder.substr( 1 );
+                    }
+                    else {
+                        spliceLine( indent, remainder, width-1 );
+                        lines.back() += "-";
+                    }
+                    if( lines.size() == 1 )
+                        indent = _attr.indent;
+                    if( tabPos != std::string::npos )
+                        indent += tabPos;
+                }
+            }
+        }
+
+        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
+            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
+            _remainder = _remainder.substr( _pos );
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TBC_TEXT_FORMAT_H_INCLUDED
+
+// ----------- end of #include from tbc_text_format.h -----------
+// ........... back in clara.h
+
+#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
+
+// ----------- #included from clara_compilers.h -----------
+
+#ifndef TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
+#define TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
+
+// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
+// The following features are defined:
+//
+// CLARA_CONFIG_CPP11_NULLPTR : is nullptr supported?
+// CLARA_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
+// CLARA_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
+// CLARA_CONFIG_CPP11_OVERRIDE : is override supported?
+// CLARA_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
+
+// CLARA_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
+
+// CLARA_CONFIG_VARIADIC_MACROS : are variadic macros supported?
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CLARA_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+// All the C++11 features can be disabled with CLARA_CONFIG_NO_CPP11
+
+#ifdef __clang__
+
+#if __has_feature(cxx_nullptr)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+#if __has_feature(cxx_noexcept)
+#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#endif
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+// - otherwise more recent versions define __cplusplus >= 201103L
+// and will get picked up below
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#if (_MSC_VER >= 1600)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
+#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#endif
+
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// C++ language feature support
+
+// catch all support for C++11
+#if defined(__cplusplus) && __cplusplus >= 201103L
+
+#define CLARA_CPP11_OR_GREATER
+
+#if !defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+#ifndef CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#endif
+
+#ifndef CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#endif
+
+#if !defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE)
+#define CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE
+#endif
+#if !defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
+#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#endif // __cplusplus >= 201103L
+
+// Now set the actual defines based on the above + anything the user has configured
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NO_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_NULLPTR
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_NOEXCEPT
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_GENERATED_METHODS
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_OVERRIDE) && !defined(CLARA_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_OVERRIDE
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_UNIQUE_PTR) && !defined(CLARA_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+// noexcept support:
+#if defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_NOEXCEPT)
+#define CLARA_NOEXCEPT noexcept
+#  define CLARA_NOEXCEPT_IS(x) noexcept(x)
+#else
+#define CLARA_NOEXCEPT throw()
+#  define CLARA_NOEXCEPT_IS(x)
+#endif
+
+// nullptr support
+#ifdef CLARA_CONFIG_CPP11_NULLPTR
+#define CLARA_NULL nullptr
+#else
+#define CLARA_NULL NULL
+#endif
+
+// override support
+#ifdef CLARA_CONFIG_CPP11_OVERRIDE
+#define CLARA_OVERRIDE override
+#else
+#define CLARA_OVERRIDE
+#endif
+
+// unique_ptr support
+#ifdef CLARA_CONFIG_CPP11_UNIQUE_PTR
+#   define CLARA_AUTO_PTR( T ) std::unique_ptr<T>
+#else
+#   define CLARA_AUTO_PTR( T ) std::auto_ptr<T>
+#endif
+
+#endif // TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
+
+// ----------- end of #include from clara_compilers.h -----------
+// ........... back in clara.h
+
+#include <map>
+#include <stdexcept>
+#include <memory>
+
+#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define CLARA_PLATFORM_WINDOWS
+#endif
+
+// Use optional outer namespace
+#ifdef STITCH_CLARA_OPEN_NAMESPACE
+STITCH_CLARA_OPEN_NAMESPACE
+#endif
+
+namespace Clara {
+
+    struct UnpositionalTag {};
+
+    extern UnpositionalTag _;
+
+#ifdef CLARA_CONFIG_MAIN
+    UnpositionalTag _;
+#endif
+
+    namespace Detail {
+
+#ifdef CLARA_CONSOLE_WIDTH
+    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+        using namespace Tbc;
+
+        inline bool startsWith( std::string const& str, std::string const& prefix ) {
+            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
+        }
+
+        template<typename T> struct RemoveConstRef{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
+
+        template<typename T>    struct IsBool       { static const bool value = false; };
+        template<>              struct IsBool<bool> { static const bool value = true; };
+
+        template<typename T>
+        void convertInto( std::string const& _source, T& _dest ) {
+            std::stringstream ss;
+            ss << _source;
+            ss >> _dest;
+            if( ss.fail() )
+                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
+        }
+        inline void convertInto( std::string const& _source, std::string& _dest ) {
+            _dest = _source;
+        }
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( c ) );
+        }
+        inline void convertInto( std::string const& _source, bool& _dest ) {
+            std::string sourceLC = _source;
+            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), toLowerCh );
+            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
+                _dest = true;
+            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
+                _dest = false;
+            else
+                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
+        }
+
+        template<typename ConfigT>
+        struct IArgFunction {
+            virtual ~IArgFunction() {}
+#ifdef CLARA_CONFIG_CPP11_GENERATED_METHODS
+            IArgFunction()                      = default;
+            IArgFunction( IArgFunction const& ) = default;
+#endif
+            virtual void set( ConfigT& config, std::string const& value ) const = 0;
+            virtual bool takesArg() const = 0;
+            virtual IArgFunction* clone() const = 0;
+        };
+
+        template<typename ConfigT>
+        class BoundArgFunction {
+        public:
+            BoundArgFunction() : functionObj( CLARA_NULL ) {}
+            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
+            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : CLARA_NULL ) {}
+            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
+                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL;
+                delete functionObj;
+                functionObj = newFunctionObj;
+                return *this;
+            }
+            ~BoundArgFunction() { delete functionObj; }
+
+            void set( ConfigT& config, std::string const& value ) const {
+                functionObj->set( config, value );
+            }
+            bool takesArg() const { return functionObj->takesArg(); }
+
+            bool isSet() const {
+                return functionObj != CLARA_NULL;
+            }
+        private:
+            IArgFunction<ConfigT>* functionObj;
+        };
+
+        template<typename C>
+        struct NullBinder : IArgFunction<C>{
+            virtual void set( C&, std::string const& ) const {}
+            virtual bool takesArg() const { return true; }
+            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
+        };
+
+        template<typename C, typename M>
+        struct BoundDataMember : IArgFunction<C>{
+            BoundDataMember( M C::* _member ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                convertInto( stringValue, p.*member );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
+            M C::* member;
+        };
+        template<typename C, typename M>
+        struct BoundUnaryMethod : IArgFunction<C>{
+            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( stringValue, value );
+                (p.*member)( value );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
+            void (C::*member)( M );
+        };
+        template<typename C>
+        struct BoundNullaryMethod : IArgFunction<C>{
+            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    (p.*member)();
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
+            void (C::*member)();
+        };
+
+        template<typename C>
+        struct BoundUnaryFunction : IArgFunction<C>{
+            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    function( obj );
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
+            void (*function)( C& );
+        };
+
+        template<typename C, typename T>
+        struct BoundBinaryFunction : IArgFunction<C>{
+            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( stringValue, value );
+                function( obj, value );
+            }
+            virtual bool takesArg() const { return !IsBool<T>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
+            void (*function)( C&, T );
+        };
+
+    } // namespace Detail
+
+    inline std::vector<std::string> argsToVector( int argc, char const* const* const argv ) {
+        std::vector<std::string> args( static_cast<std::size_t>( argc ) );
+        for( std::size_t i = 0; i < static_cast<std::size_t>( argc ); ++i )
+            args[i] = argv[i];
+
+        return args;
+    }
+
+    class Parser {
+        enum Mode { None, MaybeShortOpt, SlashOpt, ShortOpt, LongOpt, Positional };
+        Mode mode;
+        std::size_t from;
+        bool inQuotes;
+    public:
+
+        struct Token {
+            enum Type { Positional, ShortOpt, LongOpt };
+            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
+            Type type;
+            std::string data;
+        };
+
+        Parser() : mode( None ), from( 0 ), inQuotes( false ){}
+
+        void parseIntoTokens( std::vector<std::string> const& args, std::vector<Token>& tokens ) {
+            const std::string doubleDash = "--";
+            for( std::size_t i = 1; i < args.size() && args[i] != doubleDash; ++i )
+                parseIntoTokens( args[i], tokens);
+        }
+
+        void parseIntoTokens( std::string const& arg, std::vector<Token>& tokens ) {
+            for( std::size_t i = 0; i < arg.size(); ++i ) {
+                char c = arg[i];
+                if( c == '"' )
+                    inQuotes = !inQuotes;
+                mode = handleMode( i, c, arg, tokens );
+            }
+            mode = handleMode( arg.size(), '\0', arg, tokens );
+        }
+        Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
+            switch( mode ) {
+                case None: return handleNone( i, c );
+                case MaybeShortOpt: return handleMaybeShortOpt( i, c );
+                case ShortOpt:
+                case LongOpt:
+                case SlashOpt: return handleOpt( i, c, arg, tokens );
+                case Positional: return handlePositional( i, c, arg, tokens );
+                default: throw std::logic_error( "Unknown mode" );
+            }
+        }
+
+        Mode handleNone( std::size_t i, char c ) {
+            if( inQuotes ) {
+                from = i;
+                return Positional;
+            }
+            switch( c ) {
+                case '-': return MaybeShortOpt;
+#ifdef CLARA_PLATFORM_WINDOWS
+                case '/': from = i+1; return SlashOpt;
+#endif
+                default: from = i; return Positional;
+            }
+        }
+        Mode handleMaybeShortOpt( std::size_t i, char c ) {
+            switch( c ) {
+                case '-': from = i+1; return LongOpt;
+                default: from = i; return ShortOpt;
+            }
+        }
+
+        Mode handleOpt( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
+            if( std::string( ":=\0", 3 ).find( c ) == std::string::npos )
+                return mode;
+
+            std::string optName = arg.substr( from, i-from );
+            if( mode == ShortOpt )
+                for( std::size_t j = 0; j < optName.size(); ++j )
+                    tokens.push_back( Token( Token::ShortOpt, optName.substr( j, 1 ) ) );
+            else if( mode == SlashOpt && optName.size() == 1 )
+                tokens.push_back( Token( Token::ShortOpt, optName ) );
+            else
+                tokens.push_back( Token( Token::LongOpt, optName ) );
+            return None;
+        }
+        Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
+            if( inQuotes || std::string( "\0", 1 ).find( c ) == std::string::npos )
+                return mode;
+
+            std::string data = arg.substr( from, i-from );
+            tokens.push_back( Token( Token::Positional, data ) );
+            return None;
+        }
+    };
+
+    template<typename ConfigT>
+    struct CommonArgProperties {
+        CommonArgProperties() {}
+        CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
+
+        Detail::BoundArgFunction<ConfigT> boundField;
+        std::string description;
+        std::string detail;
+        std::string placeholder; // Only value if boundField takes an arg
+
+        bool takesArg() const {
+            return !placeholder.empty();
+        }
+        void validate() const {
+            if( !boundField.isSet() )
+                throw std::logic_error( "option not bound" );
+        }
+    };
+    struct OptionArgProperties {
+        std::vector<std::string> shortNames;
+        std::string longName;
+
+        bool hasShortName( std::string const& shortName ) const {
+            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
+        }
+        bool hasLongName( std::string const& _longName ) const {
+            return _longName == longName;
+        }
+    };
+    struct PositionalArgProperties {
+        PositionalArgProperties() : position( -1 ) {}
+        int position; // -1 means non-positional (floating)
+
+        bool isFixedPositional() const {
+            return position != -1;
+        }
+    };
+
+    template<typename ConfigT>
+    class CommandLine {
+
+        struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties {
+            Arg() {}
+            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : CommonArgProperties<ConfigT>( _boundField ) {}
+
+            using CommonArgProperties<ConfigT>::placeholder; // !TBD
+
+            std::string dbgName() const {
+                if( !longName.empty() )
+                    return "--" + longName;
+                if( !shortNames.empty() )
+                    return "-" + shortNames[0];
+                return "positional args";
+            }
+            std::string commands() const {
+                std::ostringstream oss;
+                bool first = true;
+                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
+                for(; it != itEnd; ++it ) {
+                    if( first )
+                        first = false;
+                    else
+                        oss << ", ";
+                    oss << "-" << *it;
+                }
+                if( !longName.empty() ) {
+                    if( !first )
+                        oss << ", ";
+                    oss << "--" << longName;
+                }
+                if( !placeholder.empty() )
+                    oss << " <" << placeholder << ">";
+                return oss.str();
+            }
+        };
+
+        typedef CLARA_AUTO_PTR( Arg ) ArgAutoPtr;
+
+        friend void addOptName( Arg& arg, std::string const& optName )
+        {
+            if( optName.empty() )
+                return;
+            if( Detail::startsWith( optName, "--" ) ) {
+                if( !arg.longName.empty() )
+                    throw std::logic_error( "Only one long opt may be specified. '"
+                        + arg.longName
+                        + "' already specified, now attempting to add '"
+                        + optName + "'" );
+                arg.longName = optName.substr( 2 );
+            }
+            else if( Detail::startsWith( optName, "-" ) )
+                arg.shortNames.push_back( optName.substr( 1 ) );
+            else
+                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
+        }
+        friend void setPositionalArg( Arg& arg, int position )
+        {
+            arg.position = position;
+        }
+
+        class ArgBuilder {
+        public:
+            ArgBuilder( Arg* arg ) : m_arg( arg ) {}
+
+            // Bind a non-boolean data member (requires placeholder string)
+            template<typename C, typename M>
+            void bind( M C::* field, std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
+                m_arg->placeholder = placeholder;
+            }
+            // Bind a boolean data member (no placeholder required)
+            template<typename C>
+            void bind( bool C::* field ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
+            }
+
+            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
+            template<typename C, typename M>
+            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,M>( unaryMethod );
+                m_arg->placeholder = placeholder;
+            }
+
+            // Bind a method taking a single, boolean argument (no placeholder string required)
+            template<typename C>
+            void bind( void (C::* unaryMethod)( bool ) ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,bool>( unaryMethod );
+            }
+
+            // Bind a method that takes no arguments (will be called if opt is present)
+            template<typename C>
+            void bind( void (C::* nullaryMethod)() ) {
+                m_arg->boundField = new Detail::BoundNullaryMethod<C>( nullaryMethod );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
+            template<typename C>
+            void bind( void (* unaryFunction)( C& ) ) {
+                m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
+            template<typename C, typename T>
+            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
+                m_arg->placeholder = placeholder;
+            }
+
+            ArgBuilder& describe( std::string const& description ) {
+                m_arg->description = description;
+                return *this;
+            }
+            ArgBuilder& detail( std::string const& detail ) {
+                m_arg->detail = detail;
+                return *this;
+            }
+
+        protected:
+            Arg* m_arg;
+        };
+
+        class OptBuilder : public ArgBuilder {
+        public:
+            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
+            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}
+
+            OptBuilder& operator[]( std::string const& optName ) {
+                addOptName( *ArgBuilder::m_arg, optName );
+                return *this;
+            }
+        };
+
+    public:
+
+        CommandLine()
+        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
+            m_highestSpecifiedArgPosition( 0 ),
+            m_throwOnUnrecognisedTokens( false )
+        {}
+        CommandLine( CommandLine const& other )
+        :   m_boundProcessName( other.m_boundProcessName ),
+            m_options ( other.m_options ),
+            m_positionalArgs( other.m_positionalArgs ),
+            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
+            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
+        {
+            if( other.m_floatingArg.get() )
+                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
+        }
+
+        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
+            m_throwOnUnrecognisedTokens = shouldThrow;
+            return *this;
+        }
+
+        OptBuilder operator[]( std::string const& optName ) {
+            m_options.push_back( Arg() );
+            addOptName( m_options.back(), optName );
+            OptBuilder builder( &m_options.back() );
+            return builder;
+        }
+
+        ArgBuilder operator[]( int position ) {
+            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
+            if( position > m_highestSpecifiedArgPosition )
+                m_highestSpecifiedArgPosition = position;
+            setPositionalArg( m_positionalArgs[position], position );
+            ArgBuilder builder( &m_positionalArgs[position] );
+            return builder;
+        }
+
+        // Invoke this with the _ instance
+        ArgBuilder operator[]( UnpositionalTag ) {
+            if( m_floatingArg.get() )
+                throw std::logic_error( "Only one unpositional argument can be added" );
+            m_floatingArg.reset( new Arg() );
+            ArgBuilder builder( m_floatingArg.get() );
+            return builder;
+        }
+
+        template<typename C, typename M>
+        void bindProcessName( M C::* field ) {
+            m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
+        }
+        template<typename C, typename M>
+        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
+            m_boundProcessName = new Detail::BoundUnaryMethod<C,M>( _unaryMethod );
+        }
+
+        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
+            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
+            std::size_t maxWidth = 0;
+            for( it = itBegin; it != itEnd; ++it )
+                maxWidth = (std::max)( maxWidth, it->commands().size() );
+
+            for( it = itBegin; it != itEnd; ++it ) {
+                Detail::Text usage( it->commands(), Detail::TextAttributes()
+                                                        .setWidth( maxWidth+indent )
+                                                        .setIndent( indent ) );
+                Detail::Text desc( it->description, Detail::TextAttributes()
+                                                        .setWidth( width - maxWidth - 3 ) );
+
+                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
+                    std::string usageCol = i < usage.size() ? usage[i] : "";
+                    os << usageCol;
+
+                    if( i < desc.size() && !desc[i].empty() )
+                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
+                            << desc[i];
+                    os << "\n";
+                }
+            }
+        }
+        std::string optUsage() const {
+            std::ostringstream oss;
+            optUsage( oss );
+            return oss.str();
+        }
+
+        void argSynopsis( std::ostream& os ) const {
+            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
+                if( i > 1 )
+                    os << " ";
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
+                if( it != m_positionalArgs.end() )
+                    os << "<" << it->second.placeholder << ">";
+                else if( m_floatingArg.get() )
+                    os << "<" << m_floatingArg->placeholder << ">";
+                else
+                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
+            }
+            // !TBD No indication of mandatory args
+            if( m_floatingArg.get() ) {
+                if( m_highestSpecifiedArgPosition > 1 )
+                    os << " ";
+                os << "[<" << m_floatingArg->placeholder << "> ...]";
+            }
+        }
+        std::string argSynopsis() const {
+            std::ostringstream oss;
+            argSynopsis( oss );
+            return oss.str();
+        }
+
+        void usage( std::ostream& os, std::string const& procName ) const {
+            validate();
+            os << "usage:\n  " << procName << " ";
+            argSynopsis( os );
+            if( !m_options.empty() ) {
+                os << " [options]\n\nwhere options are: \n";
+                optUsage( os, 2 );
+            }
+            os << "\n";
+        }
+        std::string usage( std::string const& procName ) const {
+            std::ostringstream oss;
+            usage( oss, procName );
+            return oss.str();
+        }
+
+        ConfigT parse( std::vector<std::string> const& args ) const {
+            ConfigT config;
+            parseInto( args, config );
+            return config;
+        }
+
+        std::vector<Parser::Token> parseInto( std::vector<std::string> const& args, ConfigT& config ) const {
+            std::string processName = args.empty() ? std::string() : args[0];
+            std::size_t lastSlash = processName.find_last_of( "/\\" );
+            if( lastSlash != std::string::npos )
+                processName = processName.substr( lastSlash+1 );
+            m_boundProcessName.set( config, processName );
+            std::vector<Parser::Token> tokens;
+            Parser parser;
+            parser.parseIntoTokens( args, tokens );
+            return populate( tokens, config );
+        }
+
+        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            validate();
+            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
+            unusedTokens = populateFixedArgs( unusedTokens, config );
+            unusedTokens = populateFloatingArgs( unusedTokens, config );
+            return unusedTokens;
+        }
+
+        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            std::vector<std::string> errors;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
+                for(; it != itEnd; ++it ) {
+                    Arg const& arg = *it;
+
+                    try {
+                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
+                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
+                            if( arg.takesArg() ) {
+                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
+                                    errors.push_back( "Expected argument to option: " + token.data );
+                                else
+                                    arg.boundField.set( config, tokens[++i].data );
+                            }
+                            else {
+                                arg.boundField.set( config, "true" );
+                            }
+                            break;
+                        }
+                    }
+                    catch( std::exception& ex ) {
+                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
+                    }
+                }
+                if( it == itEnd ) {
+                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
+                        unusedTokens.push_back( token );
+                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
+                        errors.push_back( "unrecognised option: " + token.data );
+                }
+            }
+            if( !errors.empty() ) {
+                std::ostringstream oss;
+                for( std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
+                        it != itEnd;
+                        ++it ) {
+                    if( it != errors.begin() )
+                        oss << "\n";
+                    oss << *it;
+                }
+                throw std::runtime_error( oss.str() );
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            int position = 1;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
+                if( it != m_positionalArgs.end() )
+                    it->second.boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+                if( token.type == Parser::Token::Positional )
+                    position++;
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            if( !m_floatingArg.get() )
+                return tokens;
+            std::vector<Parser::Token> unusedTokens;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                if( token.type == Parser::Token::Positional )
+                    m_floatingArg->boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+            }
+            return unusedTokens;
+        }
+
+        void validate() const
+        {
+            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
+                throw std::logic_error( "No options or arguments specified" );
+
+            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
+                                                            itEnd = m_options.end();
+                    it != itEnd; ++it )
+                it->validate();
+        }
+
+    private:
+        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
+        std::vector<Arg> m_options;
+        std::map<int, Arg> m_positionalArgs;
+        ArgAutoPtr m_floatingArg;
+        int m_highestSpecifiedArgPosition;
+        bool m_throwOnUnrecognisedTokens;
+    };
+
+} // end namespace Clara
+
+STITCH_CLARA_CLOSE_NAMESPACE
+#undef STITCH_CLARA_OPEN_NAMESPACE
+#undef STITCH_CLARA_CLOSE_NAMESPACE
+
+#endif // TWOBLUECUBES_CLARA_H_INCLUDED
+#undef STITCH_CLARA_OPEN_NAMESPACE
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#include <fstream>
+#include <ctime>
+
+namespace Catch {
+
+    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
+    inline void abortAfterX( ConfigData& config, int x ) {
+        if( x < 1 )
+            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
+        config.abortAfter = x;
+    }
+    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
+    inline void addSectionToRun( ConfigData& config, std::string const& sectionName ) { config.sectionsToRun.push_back( sectionName ); }
+    inline void addReporterName( ConfigData& config, std::string const& _reporterName ) { config.reporterNames.push_back( _reporterName ); }
+
+    inline void addWarning( ConfigData& config, std::string const& _warning ) {
+        if( _warning == "NoAssertions" )
+            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
+        else
+            throw std::runtime_error( "Unrecognised warning: '" + _warning + '\'' );
+    }
+    inline void setOrder( ConfigData& config, std::string const& order ) {
+        if( startsWith( "declared", order ) )
+            config.runOrder = RunTests::InDeclarationOrder;
+        else if( startsWith( "lexical", order ) )
+            config.runOrder = RunTests::InLexicographicalOrder;
+        else if( startsWith( "random", order ) )
+            config.runOrder = RunTests::InRandomOrder;
+        else
+            throw std::runtime_error( "Unrecognised ordering: '" + order + '\'' );
+    }
+    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
+        if( seed == "time" ) {
+            config.rngSeed = static_cast<unsigned int>( std::time(0) );
+        }
+        else {
+            std::stringstream ss;
+            ss << seed;
+            ss >> config.rngSeed;
+            if( ss.fail() )
+                throw std::runtime_error( "Argument to --rng-seed should be the word 'time' or a number" );
+        }
+    }
+    inline void setVerbosity( ConfigData& config, int level ) {
+        // !TBD: accept strings?
+        config.verbosity = static_cast<Verbosity::Level>( level );
+    }
+    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
+        config.showDurations = _showDurations
+            ? ShowDurations::Always
+            : ShowDurations::Never;
+    }
+    inline void setUseColour( ConfigData& config, std::string const& value ) {
+        std::string mode = toLower( value );
+
+        if( mode == "yes" )
+            config.useColour = UseColour::Yes;
+        else if( mode == "no" )
+            config.useColour = UseColour::No;
+        else if( mode == "auto" )
+            config.useColour = UseColour::Auto;
+        else
+            throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
+    }
+    inline void setWaitForKeypress( ConfigData& config, std::string const& keypress ) {
+        std::string keypressLc = toLower( keypress );
+        if( keypressLc == "start" )
+            config.waitForKeypress = WaitForKeypress::BeforeStart;
+        else if( keypressLc == "exit" )
+            config.waitForKeypress = WaitForKeypress::BeforeExit;
+        else if( keypressLc == "both" )
+            config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+        else
+            throw std::runtime_error( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
+    };
+
+    inline void forceColour( ConfigData& config ) {
+        config.useColour = UseColour::Yes;
+    }
+    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
+        std::ifstream f( _filename.c_str() );
+        if( !f.is_open() )
+            throw std::domain_error( "Unable to load input file: " + _filename );
+
+        std::string line;
+        while( std::getline( f, line ) ) {
+            line = trim(line);
+            if( !line.empty() && !startsWith( line, '#' ) ) {
+                if( !startsWith( line, '"' ) )
+                    line = '"' + line + '"';
+                addTestOrTags( config, line + ',' );
+            }
+        }
+    }
+
+    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
+
+        using namespace Clara;
+        CommandLine<ConfigData> cli;
+
+        cli.bindProcessName( &ConfigData::processName );
+
+        cli["-?"]["-h"]["--help"]
+            .describe( "display usage information" )
+            .bind( &ConfigData::showHelp );
+
+        cli["-l"]["--list-tests"]
+            .describe( "list all/matching test cases" )
+            .bind( &ConfigData::listTests );
+
+        cli["-t"]["--list-tags"]
+            .describe( "list all/matching tags" )
+            .bind( &ConfigData::listTags );
+
+        cli["-s"]["--success"]
+            .describe( "include successful tests in output" )
+            .bind( &ConfigData::showSuccessfulTests );
+
+        cli["-b"]["--break"]
+            .describe( "break into debugger on failure" )
+            .bind( &ConfigData::shouldDebugBreak );
+
+        cli["-e"]["--nothrow"]
+            .describe( "skip exception tests" )
+            .bind( &ConfigData::noThrow );
+
+        cli["-i"]["--invisibles"]
+            .describe( "show invisibles (tabs, newlines)" )
+            .bind( &ConfigData::showInvisibles );
+
+        cli["-o"]["--out"]
+            .describe( "output filename" )
+            .bind( &ConfigData::outputFilename, "filename" );
+
+        cli["-r"]["--reporter"]
+//            .placeholder( "name[:filename]" )
+            .describe( "reporter to use (defaults to console)" )
+            .bind( &addReporterName, "name" );
+
+        cli["-n"]["--name"]
+            .describe( "suite name" )
+            .bind( &ConfigData::name, "name" );
+
+        cli["-a"]["--abort"]
+            .describe( "abort at first failure" )
+            .bind( &abortAfterFirst );
+
+        cli["-x"]["--abortx"]
+            .describe( "abort after x failures" )
+            .bind( &abortAfterX, "no. failures" );
+
+        cli["-w"]["--warn"]
+            .describe( "enable warnings" )
+            .bind( &addWarning, "warning name" );
+
+// - needs updating if reinstated
+//        cli.into( &setVerbosity )
+//            .describe( "level of verbosity (0=no output)" )
+//            .shortOpt( "v")
+//            .longOpt( "verbosity" )
+//            .placeholder( "level" );
+
+        cli[_]
+            .describe( "which test or tests to use" )
+            .bind( &addTestOrTags, "test name, pattern or tags" );
+
+        cli["-d"]["--durations"]
+            .describe( "show test durations" )
+            .bind( &setShowDurations, "yes|no" );
+
+        cli["-f"]["--input-file"]
+            .describe( "load test names to run from a file" )
+            .bind( &loadTestNamesFromFile, "filename" );
+
+        cli["-#"]["--filenames-as-tags"]
+            .describe( "adds a tag for the filename" )
+            .bind( &ConfigData::filenamesAsTags );
+
+        cli["-c"]["--section"]
+                .describe( "specify section to run" )
+                .bind( &addSectionToRun, "section name" );
+
+        // Less common commands which don't have a short form
+        cli["--list-test-names-only"]
+            .describe( "list all/matching test cases names only" )
+            .bind( &ConfigData::listTestNamesOnly );
+
+        cli["--list-extra-info"]
+            .describe( "list all/matching test cases with more info" )
+            .bind( &ConfigData::listExtraInfo );
+
+        cli["--list-reporters"]
+            .describe( "list all reporters" )
+            .bind( &ConfigData::listReporters );
+
+        cli["--order"]
+            .describe( "test case order (defaults to decl)" )
+            .bind( &setOrder, "decl|lex|rand" );
+
+        cli["--rng-seed"]
+            .describe( "set a specific seed for random numbers" )
+            .bind( &setRngSeed, "'time'|number" );
+
+        cli["--force-colour"]
+            .describe( "force colourised output (deprecated)" )
+            .bind( &forceColour );
+
+        cli["--use-colour"]
+            .describe( "should output be colourised" )
+            .bind( &setUseColour, "yes|no" );
+
+        cli["--libidentify"]
+            .describe( "report name and version according to libidentify standard" )
+            .bind( &ConfigData::libIdentify );
+
+        cli["--wait-for-keypress"]
+                .describe( "waits for a keypress before exiting" )
+                .bind( &setWaitForKeypress, "start|exit|both" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_list.hpp
+#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
+
+// #included from: catch_text.h
+#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
+
+#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
+// #included from: ../external/tbc_text_format.h
+// Only use header guard if we are not using an outer namespace
+#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#  endif
+# else
+#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+# endif
+#endif
+#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#include <string>
+#include <vector>
+#include <sstream>
+
+// Use optional outer namespace
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            const std::string wrappableBeforeChars = "[({<\t";
+            const std::string wrappableAfterChars = "])}>-,./|\\";
+            const std::string wrappableInsteadOfChars = " \n\r";
+            std::string indent = _attr.initialIndent != std::string::npos
+                ? std::string( _attr.initialIndent, ' ' )
+                : std::string( _attr.indent, ' ' );
+
+            typedef std::string::const_iterator iterator;
+            iterator it = _str.begin();
+            const iterator strEnd = _str.end();
+
+            while( it != strEnd ) {
+
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+
+                std::string suffix;
+                std::size_t width = (std::min)( static_cast<size_t>( strEnd-it ), _attr.width-static_cast<size_t>( indent.size() ) );
+                iterator itEnd = it+width;
+                iterator itNext = _str.end();
+
+                iterator itNewLine = std::find( it, itEnd, '\n' );
+                if( itNewLine != itEnd )
+                    itEnd = itNewLine;
+
+                if( itEnd != strEnd  ) {
+                    bool foundWrapPoint = false;
+                    iterator findIt = itEnd;
+                    do {
+                        if( wrappableAfterChars.find( *findIt ) != std::string::npos && findIt != itEnd ) {
+                            itEnd = findIt+1;
+                            itNext = findIt+1;
+                            foundWrapPoint = true;
+                        }
+                        else if( findIt > it && wrappableBeforeChars.find( *findIt ) != std::string::npos ) {
+                            itEnd = findIt;
+                            itNext = findIt;
+                            foundWrapPoint = true;
+                        }
+                        else if( wrappableInsteadOfChars.find( *findIt ) != std::string::npos ) {
+                            itNext = findIt+1;
+                            itEnd = findIt;
+                            foundWrapPoint = true;
+                        }
+                        if( findIt == it )
+                            break;
+                        else
+                            --findIt;
+                    }
+                    while( !foundWrapPoint );
+
+                    if( !foundWrapPoint ) {
+                        // No good wrap char, so we'll break mid word and add a hyphen
+                        --itEnd;
+                        itNext = itEnd;
+                        suffix = "-";
+                    }
+                    else {
+                        while( itEnd > it && wrappableInsteadOfChars.find( *(itEnd-1) ) != std::string::npos )
+                            --itEnd;
+                    }
+                }
+                lines.push_back( indent + std::string( it, itEnd ) + suffix );
+
+                if( indent.size() != _attr.indent )
+                    indent = std::string( _attr.indent, ' ' );
+                it = itNext;
+            }
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+
+namespace Catch {
+    using Tbc::Text;
+    using Tbc::TextAttributes;
+}
+
+// #included from: catch_console_colour.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = Yellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = Yellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour const& other );
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        bool m_moved;
+    };
+
+    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_reporter.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
+
+#include <string>
+#include <ostream>
+#include <map>
+
+namespace Catch
+{
+    struct ReporterConfig {
+        explicit ReporterConfig( Ptr<IConfig const> const& _fullConfig )
+        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+        ReporterConfig( Ptr<IConfig const> const& _fullConfig, std::ostream& _stream )
+        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+        std::ostream& stream() const    { return *m_stream; }
+        Ptr<IConfig const> fullConfig() const { return m_fullConfig; }
+
+    private:
+        std::ostream* m_stream;
+        Ptr<IConfig const> m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        ReporterPreferences()
+        : shouldRedirectStdOut( false )
+        {}
+
+        bool shouldRedirectStdOut;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat() : used( false ) {}
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name ) : name( _name ) {}
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount )
+        :   name( _name ),
+            groupIndex( _groupIndex ),
+            groupsCounts( _groupsCount )
+        {}
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals )
+        :   assertionResult( _assertionResult ),
+            infoMessages( _infoMessages ),
+            totals( _totals )
+        {
+            if( assertionResult.hasMessage() ) {
+                // Copy message into messages list.
+                // !TBD This should have been done earlier, somewhere
+                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+                builder << assertionResult.getMessage();
+                builder.m_info.message = builder.m_stream.str();
+
+                infoMessages.push_back( builder.m_info );
+            }
+        }
+        virtual ~AssertionStats();
+
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = default;
+        AssertionStats& operator = ( AssertionStats && )     = default;
+#  endif
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions )
+        :   sectionInfo( _sectionInfo ),
+            assertions( _assertions ),
+            durationInSeconds( _durationInSeconds ),
+            missingAssertions( _missingAssertions )
+        {}
+        virtual ~SectionStats();
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+#  endif
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting )
+        : testInfo( _testInfo ),
+            totals( _totals ),
+            stdOut( _stdOut ),
+            stdErr( _stdErr ),
+            aborting( _aborting )
+        {}
+        virtual ~TestCaseStats();
+
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+#  endif
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   groupInfo( _groupInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        TestGroupStats( GroupInfo const& _groupInfo )
+        :   groupInfo( _groupInfo ),
+            aborting( false )
+        {}
+        virtual ~TestGroupStats();
+
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+#  endif
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   runInfo( _runInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        virtual ~TestRunStats();
+
+#  ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        TestRunStats( TestRunStats const& _other )
+        :   runInfo( _other.runInfo ),
+            totals( _other.totals ),
+            aborting( _other.aborting )
+        {}
+#  else
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+#  endif
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    class MultipleReporters;
+
+    struct IStreamingReporter : IShared {
+        virtual ~IStreamingReporter();
+
+        // Implementing class must also provide the following static method:
+        // static std::string getDescription();
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        virtual MultipleReporters* tryAsMulti() { return CATCH_NULL; }
+    };
+
+    struct IReporterFactory : IShared {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+
+    struct IReporterRegistry {
+        typedef std::map<std::string, Ptr<IReporterFactory> > FactoryMap;
+        typedef std::vector<Ptr<IReporterFactory> > Listeners;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+    Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter );
+
+}
+
+#include <limits>
+#include <algorithm>
+
+namespace Catch {
+
+    inline std::size_t listTests( Config const& config ) {
+
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::size_t matchedTests = 0;
+        TextAttributes nameAttr, descAttr, tagsAttr;
+        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
+        descAttr.setIndent( 4 );
+        tagsAttr.setIndent( 6 );
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
+            if( config.listExtraInfo() ) {
+                Catch::cout() << "    " << testCaseInfo.lineInfo << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Text( description, descAttr ) << std::endl;
+            }
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
+        }
+
+        if( !config.testSpec().hasFilters() )
+            Catch::cout() << pluralise( matchedTests, "test case" ) << '\n' << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTests, "matching test case" ) << '\n' << std::endl;
+        return matchedTests;
+    }
+
+    inline std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( !config.testSpec().hasFilters() )
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            if( startsWith( testCaseInfo.name, '#' ) )
+               Catch::cout() << '"' << testCaseInfo.name << '"';
+            else
+               Catch::cout() << testCaseInfo.name;
+            if ( config.listExtraInfo() )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
+        }
+        return matchedTests;
+    }
+
+    struct TagInfo {
+        TagInfo() : count ( 0 ) {}
+        void add( std::string const& spelling ) {
+            ++count;
+            spellings.insert( spelling );
+        }
+        std::string all() const {
+            std::string out;
+            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
+                        it != itEnd;
+                        ++it )
+                out += "[" + *it + "]";
+            return out;
+        }
+        std::set<std::string> spellings;
+        std::size_t count;
+    };
+
+    inline std::size_t listTags( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
+                                                        tagItEnd = it->getTestCaseInfo().tags.end();
+                    tagIt != tagItEnd;
+                    ++tagIt ) {
+                std::string tagName = *tagIt;
+                std::string lcaseTagName = toLower( tagName );
+                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
+                                                            countItEnd = tagCounts.end();
+                countIt != countItEnd;
+                ++countIt ) {
+            std::ostringstream oss;
+            oss << "  " << std::setw(2) << countIt->second.count << "  ";
+            Text wrapper( countIt->second.all(), TextAttributes()
+                                                    .setInitialIndent( 0 )
+                                                    .setIndent( oss.str().size() )
+                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
+            Catch::cout() << oss.str() << wrapper << '\n';
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+        return tagCounts.size();
+    }
+
+    inline std::size_t listReporters( Config const& /*config*/ ) {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
+        std::size_t maxNameLen = 0;
+        for(it = itBegin; it != itEnd; ++it )
+            maxNameLen = (std::max)( maxNameLen, it->first.size() );
+
+        for(it = itBegin; it != itEnd; ++it ) {
+            Text wrapper( it->second->getDescription(), TextAttributes()
+                                                        .setInitialIndent( 0 )
+                                                        .setIndent( 7+maxNameLen )
+                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
+            Catch::cout() << "  "
+                    << it->first
+                    << ':'
+                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
+                    << wrapper << '\n';
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    inline Option<std::size_t> list( Config const& config ) {
+        Option<std::size_t> listedCount;
+        if( config.listTests() || ( config.listExtraInfo() && !config.listTestNamesOnly() ) )
+            listedCount = listedCount.valueOr(0) + listTests( config );
+        if( config.listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
+        if( config.listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( config );
+        if( config.listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters( config );
+        return listedCount;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_run_context.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
+
+// #included from: catch_test_case_tracker.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <algorithm>
+#include <string>
+#include <assert.h>
+#include <vector>
+#include <stdexcept>
+
+CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+        :   name( _name ),
+            location( _location )
+        {}
+    };
+
+    struct ITracker : SharedImpl<> {
+        virtual ~ITracker();
+
+        // static queries
+        virtual NameAndLocation const& nameAndLocation() const = 0;
+
+        // dynamic queries
+        virtual bool isComplete() const = 0; // Successfully completed or failed
+        virtual bool isSuccessfullyCompleted() const = 0;
+        virtual bool isOpen() const = 0; // Started but not complete
+        virtual bool hasChildren() const = 0;
+
+        virtual ITracker& parent() = 0;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        virtual void markAsNeedingAnotherRun() = 0;
+
+        virtual void addChild( Ptr<ITracker> const& child ) = 0;
+        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) = 0;
+        virtual void openChild() = 0;
+
+        // Debug/ checking
+        virtual bool isSectionTracker() const = 0;
+        virtual bool isIndexTracker() const = 0;
+    };
+
+    class  TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        Ptr<ITracker> m_rootTracker;
+        ITracker* m_currentTracker;
+        RunState m_runState;
+
+    public:
+
+        static TrackerContext& instance() {
+            static TrackerContext s_instance;
+            return s_instance;
+        }
+
+        TrackerContext()
+        :   m_currentTracker( CATCH_NULL ),
+            m_runState( NotStarted )
+        {}
+
+        ITracker& startRun();
+
+        void endRun() {
+            m_rootTracker.reset();
+            m_currentTracker = CATCH_NULL;
+            m_runState = NotStarted;
+        }
+
+        void startCycle() {
+            m_currentTracker = m_rootTracker.get();
+            m_runState = Executing;
+        }
+        void completeCycle() {
+            m_runState = CompletedCycle;
+        }
+
+        bool completedCycle() const {
+            return m_runState == CompletedCycle;
+        }
+        ITracker& currentTracker() {
+            return *m_currentTracker;
+        }
+        void setCurrentTracker( ITracker* tracker ) {
+            m_currentTracker = tracker;
+        }
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+        class TrackerHasName {
+            NameAndLocation m_nameAndLocation;
+        public:
+            TrackerHasName( NameAndLocation const& nameAndLocation ) : m_nameAndLocation( nameAndLocation ) {}
+            bool operator ()( Ptr<ITracker> const& tracker ) {
+                return
+                    tracker->nameAndLocation().name == m_nameAndLocation.name &&
+                    tracker->nameAndLocation().location == m_nameAndLocation.location;
+            }
+        };
+        typedef std::vector<Ptr<ITracker> > Children;
+        NameAndLocation m_nameAndLocation;
+        TrackerContext& m_ctx;
+        ITracker* m_parent;
+        Children m_children;
+        CycleState m_runState;
+    public:
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+        :   m_nameAndLocation( nameAndLocation ),
+            m_ctx( ctx ),
+            m_parent( parent ),
+            m_runState( NotStarted )
+        {}
+        virtual ~TrackerBase();
+
+        virtual NameAndLocation const& nameAndLocation() const CATCH_OVERRIDE {
+            return m_nameAndLocation;
+        }
+        virtual bool isComplete() const CATCH_OVERRIDE {
+            return m_runState == CompletedSuccessfully || m_runState == Failed;
+        }
+        virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE {
+            return m_runState == CompletedSuccessfully;
+        }
+        virtual bool isOpen() const CATCH_OVERRIDE {
+            return m_runState != NotStarted && !isComplete();
+        }
+        virtual bool hasChildren() const CATCH_OVERRIDE {
+            return !m_children.empty();
+        }
+
+        virtual void addChild( Ptr<ITracker> const& child ) CATCH_OVERRIDE {
+            m_children.push_back( child );
+        }
+
+        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) CATCH_OVERRIDE {
+            Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( nameAndLocation ) );
+            return( it != m_children.end() )
+                ? it->get()
+                : CATCH_NULL;
+        }
+        virtual ITracker& parent() CATCH_OVERRIDE {
+            assert( m_parent ); // Should always be non-null except for root
+            return *m_parent;
+        }
+
+        virtual void openChild() CATCH_OVERRIDE {
+            if( m_runState != ExecutingChildren ) {
+                m_runState = ExecutingChildren;
+                if( m_parent )
+                    m_parent->openChild();
+            }
+        }
+
+        virtual bool isSectionTracker() const CATCH_OVERRIDE { return false; }
+        virtual bool isIndexTracker() const CATCH_OVERRIDE { return false; }
+
+        void open() {
+            m_runState = Executing;
+            moveToThis();
+            if( m_parent )
+                m_parent->openChild();
+        }
+
+        virtual void close() CATCH_OVERRIDE {
+
+            // Close any still open children (e.g. generators)
+            while( &m_ctx.currentTracker() != this )
+                m_ctx.currentTracker().close();
+
+            switch( m_runState ) {
+                case NotStarted:
+                case CompletedSuccessfully:
+                case Failed:
+                    throw std::logic_error( "Illogical state" );
+
+                case NeedsAnotherRun:
+                    break;;
+
+                case Executing:
+                    m_runState = CompletedSuccessfully;
+                    break;
+                case ExecutingChildren:
+                    if( m_children.empty() || m_children.back()->isComplete() )
+                        m_runState = CompletedSuccessfully;
+                    break;
+
+                default:
+                    throw std::logic_error( "Unexpected state" );
+            }
+            moveToParent();
+            m_ctx.completeCycle();
+        }
+        virtual void fail() CATCH_OVERRIDE {
+            m_runState = Failed;
+            if( m_parent )
+                m_parent->markAsNeedingAnotherRun();
+            moveToParent();
+            m_ctx.completeCycle();
+        }
+        virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE {
+            m_runState = NeedsAnotherRun;
+        }
+    private:
+        void moveToParent() {
+            assert( m_parent );
+            m_ctx.setCurrentTracker( m_parent );
+        }
+        void moveToThis() {
+            m_ctx.setCurrentTracker( this );
+        }
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<std::string> m_filters;
+    public:
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+        :   TrackerBase( nameAndLocation, ctx, parent )
+        {
+            if( parent ) {
+                while( !parent->isSectionTracker() )
+                    parent = &parent->parent();
+
+                SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+                addNextFilters( parentSection.m_filters );
+            }
+        }
+        virtual ~SectionTracker();
+
+        virtual bool isSectionTracker() const CATCH_OVERRIDE { return true; }
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+            SectionTracker* section = CATCH_NULL;
+
+            ITracker& currentTracker = ctx.currentTracker();
+            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                assert( childTracker );
+                assert( childTracker->isSectionTracker() );
+                section = static_cast<SectionTracker*>( childTracker );
+            }
+            else {
+                section = new SectionTracker( nameAndLocation, ctx, &currentTracker );
+                currentTracker.addChild( section );
+            }
+            if( !ctx.completedCycle() )
+                section->tryOpen();
+            return *section;
+        }
+
+        void tryOpen() {
+            if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
+                open();
+        }
+
+        void addInitialFilters( std::vector<std::string> const& filters ) {
+            if( !filters.empty() ) {
+                m_filters.push_back(""); // Root - should never be consulted
+                m_filters.push_back(""); // Test Case - not a section filter
+                m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+            }
+        }
+        void addNextFilters( std::vector<std::string> const& filters ) {
+            if( filters.size() > 1 )
+                m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
+        }
+    };
+
+    class IndexTracker : public TrackerBase {
+        int m_size;
+        int m_index;
+    public:
+        IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
+        :   TrackerBase( nameAndLocation, ctx, parent ),
+            m_size( size ),
+            m_index( -1 )
+        {}
+        virtual ~IndexTracker();
+
+        virtual bool isIndexTracker() const CATCH_OVERRIDE { return true; }
+
+        static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
+            IndexTracker* tracker = CATCH_NULL;
+
+            ITracker& currentTracker = ctx.currentTracker();
+            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                assert( childTracker );
+                assert( childTracker->isIndexTracker() );
+                tracker = static_cast<IndexTracker*>( childTracker );
+            }
+            else {
+                tracker = new IndexTracker( nameAndLocation, ctx, &currentTracker, size );
+                currentTracker.addChild( tracker );
+            }
+
+            if( !ctx.completedCycle() && !tracker->isComplete() ) {
+                if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
+                    tracker->moveNext();
+                tracker->open();
+            }
+
+            return *tracker;
+        }
+
+        int index() const { return m_index; }
+
+        void moveNext() {
+            m_index++;
+            m_children.clear();
+        }
+
+        virtual void close() CATCH_OVERRIDE {
+            TrackerBase::close();
+            if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
+                m_runState = Executing;
+        }
+    };
+
+    inline ITracker& TrackerContext::startRun() {
+        m_rootTracker = new SectionTracker( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, CATCH_NULL );
+        m_currentTracker = CATCH_NULL;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+using TestCaseTracking::IndexTracker;
+
+} // namespace Catch
+
+CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+// #included from: catch_fatal_condition.hpp
+#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
+
+namespace Catch {
+
+    // Report the error condition
+    inline void reportFatal( std::string const& message ) {
+        IContext& context = Catch::getCurrentContext();
+        IResultCapture* resultCapture = context.getResultCapture();
+        resultCapture->handleFatalErrorCondition( message );
+    }
+
+} // namespace Catch
+
+#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+// #included from: catch_windows_h_proxy.h
+
+#define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
+
+#ifdef CATCH_DEFINES_NOMINMAX
+#  define NOMINMAX
+#endif
+#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef CATCH_DEFINES_NOMINMAX
+#  undef NOMINMAX
+#endif
+#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#  undef WIN32_LEAN_AND_MEAN
+#endif
+
+
+#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset() {}
+    };
+}
+
+#  else // CATCH_CONFIG_WINDOWS_SEH is defined
+
+namespace Catch {
+
+    struct SignalDefs { DWORD id; const char* name; };
+    extern SignalDefs signalDefs[];
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    SignalDefs signalDefs[] = {
+        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
+        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
+        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
+        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+    };
+
+    struct FatalConditionHandler {
+
+        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+            for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+                if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
+                    reportFatal(signalDefs[i].name);
+                }
+            }
+            // If its not an exception we care about, pass it along.
+            // This stops us from eating debugger breaks etc.
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
+
+        FatalConditionHandler() {
+            isSet = true;
+            // 32k seems enough for Catch to handle stack overflow,
+            // but the value was found experimentally, so there is no strong guarantee
+            guaranteeSize = 32 * 1024;
+            exceptionHandlerHandle = CATCH_NULL;
+            // Register as first handler in current chain
+            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+            // Pass in guarantee size to be filled
+            SetThreadStackGuarantee(&guaranteeSize);
+        }
+
+        static void reset() {
+            if (isSet) {
+                // Unregister handler and restore the old guarantee
+                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+                SetThreadStackGuarantee(&guaranteeSize);
+                exceptionHandlerHandle = CATCH_NULL;
+                isSet = false;
+            }
+        }
+
+        ~FatalConditionHandler() {
+            reset();
+        }
+    private:
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
+    };
+
+    bool FatalConditionHandler::isSet = false;
+    ULONG FatalConditionHandler::guaranteeSize = 0;
+    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
+
+} // namespace Catch
+
+#  endif // CATCH_CONFIG_WINDOWS_SEH
+
+#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+
+#  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset() {}
+    };
+}
+
+#  else // CATCH_CONFIG_POSIX_SIGNALS is defined
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+    extern SignalDefs signalDefs[];
+    SignalDefs signalDefs[] = {
+            { SIGINT,  "SIGINT - Terminal interrupt signal" },
+            { SIGILL,  "SIGILL - Illegal instruction signal" },
+            { SIGFPE,  "SIGFPE - Floating point error signal" },
+            { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+            { SIGTERM, "SIGTERM - Termination request signal" },
+            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+    struct FatalConditionHandler {
+
+        static bool isSet;
+        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
+        static stack_t oldSigStack;
+        static char altStackMem[SIGSTKSZ];
+
+        static void handleSignal( int sig ) {
+            std::string name = "<unknown signal>";
+            for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+                SignalDefs &def = signalDefs[i];
+                if (sig == def.id) {
+                    name = def.name;
+                    break;
+                }
+            }
+            reset();
+            reportFatal(name);
+            raise( sig );
+        }
+
+        FatalConditionHandler() {
+            isSet = true;
+            stack_t sigStack;
+            sigStack.ss_sp = altStackMem;
+            sigStack.ss_size = SIGSTKSZ;
+            sigStack.ss_flags = 0;
+            sigaltstack(&sigStack, &oldSigStack);
+            struct sigaction sa = { 0 };
+
+            sa.sa_handler = handleSignal;
+            sa.sa_flags = SA_ONSTACK;
+            for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+                sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+            }
+        }
+
+        ~FatalConditionHandler() {
+            reset();
+        }
+        static void reset() {
+            if( isSet ) {
+                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+                    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
+                }
+                // Return the old stack
+                sigaltstack(&oldSigStack, CATCH_NULL);
+                isSet = false;
+            }
+        }
+    };
+
+    bool FatalConditionHandler::isSet = false;
+    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+    stack_t FatalConditionHandler::oldSigStack = {};
+    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
+
+} // namespace Catch
+
+#  endif // CATCH_CONFIG_POSIX_SIGNALS
+
+#endif // not Windows
+
+#include <set>
+#include <string>
+
+namespace Catch {
+
+    class StreamRedirect {
+
+    public:
+        StreamRedirect( std::ostream& stream, std::string& targetString )
+        :   m_stream( stream ),
+            m_prevBuf( stream.rdbuf() ),
+            m_targetString( targetString )
+        {
+            stream.rdbuf( m_oss.rdbuf() );
+        }
+
+        ~StreamRedirect() {
+            m_targetString += m_oss.str();
+            m_stream.rdbuf( m_prevBuf );
+        }
+
+    private:
+        std::ostream& m_stream;
+        std::streambuf* m_prevBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes and cannot use StreamRedirect on its own
+    class StdErrRedirect {
+    public:
+        StdErrRedirect(std::string& targetString)
+        :m_cerrBuf( cerr().rdbuf() ), m_clogBuf(clog().rdbuf()),
+        m_targetString(targetString){
+            cerr().rdbuf(m_oss.rdbuf());
+            clog().rdbuf(m_oss.rdbuf());
+        }
+        ~StdErrRedirect() {
+            m_targetString += m_oss.str();
+            cerr().rdbuf(m_cerrBuf);
+            clog().rdbuf(m_clogBuf);
+        }
+    private:
+        std::streambuf* m_cerrBuf;
+        std::streambuf* m_clogBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+        RunContext( RunContext const& );
+        void operator =( RunContext const& );
+
+    public:
+
+        explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
+        :   m_runInfo( _config->name() ),
+            m_context( getCurrentMutableContext() ),
+            m_activeTestCase( CATCH_NULL ),
+            m_config( _config ),
+            m_reporter( reporter ),
+            m_shouldReportUnexpected ( true )
+        {
+            m_context.setRunner( this );
+            m_context.setConfig( m_config );
+            m_context.setResultCapture( this );
+            m_reporter->testRunStarting( m_runInfo );
+        }
+
+        virtual ~RunContext() {
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
+        }
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
+        }
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
+        }
+
+        Totals runTest( TestCase const& testCase ) {
+            Totals prevTotals = m_totals;
+
+            std::string redirectedCout;
+            std::string redirectedCerr;
+
+            TestCaseInfo testInfo = testCase.getTestCaseInfo();
+
+            m_reporter->testCaseStarting( testInfo );
+
+            m_activeTestCase = &testCase;
+
+            do {
+                ITracker& rootTracker = m_trackerContext.startRun();
+                assert( rootTracker.isSectionTracker() );
+                static_cast<SectionTracker&>( rootTracker ).addInitialFilters( m_config->getSectionsToRun() );
+                do {
+                    m_trackerContext.startCycle();
+                    m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( testInfo.name, testInfo.lineInfo ) );
+                    runCurrentTest( redirectedCout, redirectedCerr );
+                }
+                while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() );
+            }
+            // !TBD: deprecated - this will be replaced by indexed trackers
+            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
+
+            Totals deltaTotals = m_totals.delta( prevTotals );
+            if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) {
+                deltaTotals.assertions.failed++;
+                deltaTotals.testCases.passed--;
+                deltaTotals.testCases.failed++;
+            }
+            m_totals.testCases += deltaTotals.testCases;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        redirectedCout,
+                                                        redirectedCerr,
+                                                        aborting() ) );
+
+            m_activeTestCase = CATCH_NULL;
+            m_testCaseTracker = CATCH_NULL;
+
+            return deltaTotals;
+        }
+
+        Ptr<IConfig const> config() const {
+            return m_config;
+        }
+
+    private: // IResultCapture
+
+        virtual void assertionEnded( AssertionResult const& result ) {
+            if( result.getResultType() == ResultWas::Ok ) {
+                m_totals.assertions.passed++;
+            }
+            else if( !result.isOk() ) {
+                if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                    m_totals.assertions.failedButOk++;
+                else
+                    m_totals.assertions.failed++;
+            }
+
+            // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+            // and should be let to clear themselves out.
+            static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+            // Reset working state
+            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
+            m_lastResult = result;
+        }
+
+        virtual bool lastAssertionPassed()
+        {
+            return m_totals.assertions.passed == (m_prevPassed + 1);
+        }
+
+        virtual void assertionPassed()
+        {
+            m_totals.assertions.passed++;
+            m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}";
+            m_lastAssertionInfo.macroName = "";
+        }
+
+        virtual void assertionRun()
+        {
+            m_prevPassed = m_totals.assertions.passed;
+        }
+
+        virtual bool sectionStarted (
+            SectionInfo const& sectionInfo,
+            Counts& assertions
+        )
+        {
+            ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( sectionInfo.name, sectionInfo.lineInfo ) );
+            if( !sectionTracker.isOpen() )
+                return false;
+            m_activeSections.push_back( &sectionTracker );
+
+            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+            m_reporter->sectionStarting( sectionInfo );
+
+            assertions = m_totals.assertions;
+
+            return true;
+        }
+        bool testForMissingAssertions( Counts& assertions ) {
+            if( assertions.total() != 0 )
+                return false;
+            if( !m_config->warnAboutMissingAssertions() )
+                return false;
+            if( m_trackerContext.currentTracker().hasChildren() )
+                return false;
+            m_totals.assertions.failed++;
+            assertions.failed++;
+            return true;
+        }
+
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) {
+            Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            if( !m_activeSections.empty() ) {
+                m_activeSections.back()->close();
+                m_activeSections.pop_back();
+            }
+
+            m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) );
+            m_messages.clear();
+        }
+
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) {
+            if( m_unfinishedSections.empty() )
+                m_activeSections.back()->fail();
+            else
+                m_activeSections.back()->close();
+            m_activeSections.pop_back();
+
+            m_unfinishedSections.push_back( endInfo );
+        }
+
+        virtual void pushScopedMessage( MessageInfo const& message ) {
+            m_messages.push_back( message );
+        }
+
+        virtual void popScopedMessage( MessageInfo const& message ) {
+            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
+        }
+
+        virtual std::string getCurrentTestName() const {
+            return m_activeTestCase
+                ? m_activeTestCase->getTestCaseInfo().name
+                : std::string();
+        }
+
+        virtual const AssertionResult* getLastResult() const {
+            return &m_lastResult;
+        }
+
+        virtual void exceptionEarlyReported() {
+            m_shouldReportUnexpected = false;
+        }
+
+        virtual void handleFatalErrorCondition( std::string const& message ) {
+            // Don't rebuild the result -- the stringification itself can cause more fatal errors
+            // Instead, fake a result data.
+            AssertionResultData tempResult;
+            tempResult.resultType = ResultWas::FatalErrorCondition;
+            tempResult.message = message;
+            AssertionResult result(m_lastAssertionInfo, tempResult);
+
+            getResultCapture().assertionEnded(result);
+
+            handleUnfinishedSections();
+
+            // Recreate section for test case (as we will lose the one that was in scope)
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+
+            Counts assertions;
+            assertions.failed = 1;
+            SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
+            m_reporter->sectionEnded( testCaseSectionStats );
+
+            TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
+
+            Totals deltaTotals;
+            deltaTotals.testCases.failed = 1;
+            deltaTotals.assertions.failed = 1;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        std::string(),
+                                                        std::string(),
+                                                        false ) );
+            m_totals.testCases.failed++;
+            testGroupEnded( std::string(), m_totals, 1, 1 );
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
+        }
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const {
+            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
+        }
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+            m_reporter->sectionStarting( testCaseSection );
+            Counts prevAssertions = m_totals.assertions;
+            double duration = 0;
+            m_shouldReportUnexpected = true;
+            try {
+                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
+
+                seedRng( *m_config );
+
+                Timer timer;
+                timer.start();
+                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
+                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
+                    StdErrRedirect errRedir( redirectedCerr );
+                    invokeActiveTestCase();
+                }
+                else {
+                    invokeActiveTestCase();
+                }
+                duration = timer.getElapsedSeconds();
+            }
+            catch( TestFailureException& ) {
+                // This just means the test was aborted due to failure
+            }
+            catch(...) {
+                // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+                // are reported without translation at the point of origin.
+                if (m_shouldReportUnexpected) {
+                    makeUnexpectedResultBuilder().useActiveException();
+                }
+            }
+            m_testCaseTracker->close();
+            handleUnfinishedSections();
+            m_messages.clear();
+
+            Counts assertions = m_totals.assertions - prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
+            m_reporter->sectionEnded( testCaseSectionStats );
+        }
+
+        void invokeActiveTestCase() {
+            FatalConditionHandler fatalConditionHandler; // Handle signals
+            m_activeTestCase->invoke();
+            fatalConditionHandler.reset();
+        }
+
+    private:
+
+        ResultBuilder makeUnexpectedResultBuilder() const {
+            return ResultBuilder(   m_lastAssertionInfo.macroName,
+                                    m_lastAssertionInfo.lineInfo,
+                                    m_lastAssertionInfo.capturedExpression,
+                                    m_lastAssertionInfo.resultDisposition );
+        }
+
+        void handleUnfinishedSections() {
+            // If sections ended prematurely due to an exception we stored their
+            // infos here so we can tear them down outside the unwind process.
+            for( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
+                        itEnd = m_unfinishedSections.rend();
+                    it != itEnd;
+                    ++it )
+                sectionEnded( *it );
+            m_unfinishedSections.clear();
+        }
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase;
+        ITracker* m_testCaseTracker;
+        ITracker* m_currentSectionTracker;
+        AssertionResult m_lastResult;
+
+        Ptr<IConfig const> m_config;
+        Totals m_totals;
+        Ptr<IStreamingReporter> m_reporter;
+        std::vector<MessageInfo> m_messages;
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        size_t m_prevPassed;
+        bool m_shouldReportUnexpected;
+    };
+
+    IResultCapture& getResultCapture() {
+        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
+            return *capture;
+        else
+            throw std::logic_error( "No result capture instance" );
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_version.h
+#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+
+    private:
+        void operator=( Version const& );
+    };
+
+    inline Version libraryVersion();
+}
+
+#include <fstream>
+#include <stdlib.h>
+#include <limits>
+
+namespace Catch {
+
+    Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
+        Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );
+        if( !reporter ) {
+            std::ostringstream oss;
+            oss << "No reporter registered with name: '" << reporterName << "'";
+            throw std::domain_error( oss.str() );
+        }
+        return reporter;
+    }
+
+#if !defined(CATCH_CONFIG_DEFAULT_REPORTER)
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+
+    Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
+        std::vector<std::string> reporters = config->getReporterNames();
+        if( reporters.empty() )
+            reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER );
+
+        Ptr<IStreamingReporter> reporter;
+        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
+                it != itEnd;
+                ++it )
+            reporter = addReporter( reporter, createReporter( *it, config ) );
+        return reporter;
+    }
+    Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
+        IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
+        for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
+                it != itEnd;
+                ++it )
+            reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) );
+        return reporters;
+    }
+
+    Totals runTests( Ptr<Config> const& config ) {
+
+        Ptr<IConfig const> iconfig = config.get();
+
+        Ptr<IStreamingReporter> reporter = makeReporter( config );
+        reporter = addListeners( iconfig, reporter );
+
+        RunContext context( iconfig, reporter );
+
+        Totals totals;
+
+        context.testGroupStarting( config->name(), 1, 1 );
+
+        TestSpec testSpec = config->testSpec();
+        if( !testSpec.hasFilters() )
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
+
+        std::vector<TestCase> const& allTestCases = getAllTestCasesSorted( *iconfig );
+        for( std::vector<TestCase>::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end();
+                it != itEnd;
+                ++it ) {
+            if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) )
+                totals += context.runTest( *it );
+            else
+                reporter->skipTest( *it );
+        }
+
+        context.testGroupEnded( iconfig->name(), totals, 1, 1 );
+        return totals;
+    }
+
+    void applyFilenamesAsTags( IConfig const& config ) {
+        std::vector<TestCase> const& tests = getAllTestCasesSorted( config );
+        for(std::size_t i = 0; i < tests.size(); ++i ) {
+            TestCase& test = const_cast<TestCase&>( tests[i] );
+            std::set<std::string> tags = test.tags;
+
+            std::string filename = test.lineInfo.file;
+            std::string::size_type lastSlash = filename.find_last_of( "\\/" );
+            if( lastSlash != std::string::npos )
+                filename = filename.substr( lastSlash+1 );
+
+            std::string::size_type lastDot = filename.find_last_of( '.' );
+            if( lastDot != std::string::npos )
+                filename = filename.substr( 0, lastDot );
+
+            tags.insert( '#' + filename );
+            setTags( test, tags );
+        }
+    }
+
+    class Session : NonCopyable {
+        static bool alreadyInstantiated;
+
+    public:
+
+        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
+
+        Session()
+        : m_cli( makeCommandLineParser() ) {
+            if( alreadyInstantiated ) {
+                std::string msg = "Only one instance of Catch::Session can ever be used";
+                Catch::cerr() << msg << std::endl;
+                throw std::logic_error( msg );
+            }
+            alreadyInstantiated = true;
+        }
+        ~Session() {
+            Catch::cleanUp();
+        }
+
+        void showHelp( std::string const& processName ) {
+            Catch::cout() << "\nCatch v" << libraryVersion() << "\n";
+
+            m_cli.usage( Catch::cout(), processName );
+            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
+        }
+        void libIdentify() {
+            Catch::cout()
+                    << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
+                    << std::left << std::setw(16) << "category: " << "testframework\n"
+                    << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                    << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+        }
+
+        int applyCommandLine( int argc, char const* const* const argv, OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
+            try {
+                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
+                m_unusedTokens = m_cli.parseInto( Clara::argsToVector( argc, argv ), m_configData );
+                if( m_configData.showHelp )
+                    showHelp( m_configData.processName );
+                if( m_configData.libIdentify )
+                    libIdentify();
+                m_config.reset();
+            }
+            catch( std::exception& ex ) {
+                {
+                    Colour colourGuard( Colour::Red );
+                    Catch::cerr()
+                        << "\nError(s) in input:\n"
+                        << Text( ex.what(), TextAttributes().setIndent(2) )
+                        << "\n\n";
+                }
+                m_cli.usage( Catch::cout(), m_configData.processName );
+                return (std::numeric_limits<int>::max)();
+            }
+            return 0;
+        }
+
+        void useConfigData( ConfigData const& _configData ) {
+            m_configData = _configData;
+            m_config.reset();
+        }
+
+        int run( int argc, char const* const* const argv ) {
+
+            int returnCode = applyCommandLine( argc, argv );
+            if( returnCode == 0 )
+                returnCode = run();
+            return returnCode;
+        }
+
+    #if defined(WIN32) && defined(UNICODE)
+        int run( int argc, wchar_t const* const* const argv ) {
+
+            char **utf8Argv = new char *[ argc ];
+
+            for ( int i = 0; i < argc; ++i ) {
+                int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+
+                utf8Argv[ i ] = new char[ bufSize ];
+
+                WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+            }
+
+            int returnCode = applyCommandLine( argc, utf8Argv );
+            if( returnCode == 0 )
+                returnCode = run();
+
+            for ( int i = 0; i < argc; ++i )
+                delete [] utf8Argv[ i ];
+
+            delete [] utf8Argv;
+
+            return returnCode;
+        }
+    #endif
+
+        int run() {
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            int exitCode = runInternal();
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            return exitCode;
+        }
+
+        Clara::CommandLine<ConfigData> const& cli() const {
+            return m_cli;
+        }
+        std::vector<Clara::Parser::Token> const& unusedTokens() const {
+            return m_unusedTokens;
+        }
+        ConfigData& configData() {
+            return m_configData;
+        }
+        Config& config() {
+            if( !m_config )
+                m_config = new Config( m_configData );
+            return *m_config;
+        }
+    private:
+
+        int runInternal() {
+            if( m_configData.showHelp || m_configData.libIdentify )
+                return 0;
+
+            try
+            {
+                config(); // Force config to be constructed
+
+                seedRng( *m_config );
+
+                if( m_configData.filenamesAsTags )
+                    applyFilenamesAsTags( *m_config );
+
+                // Handle list request
+                if( Option<std::size_t> listed = list( config() ) )
+                    return static_cast<int>( *listed );
+
+                return static_cast<int>( runTests( m_config ).assertions.failed );
+            }
+            catch( std::exception& ex ) {
+                Catch::cerr() << ex.what() << std::endl;
+                return (std::numeric_limits<int>::max)();
+            }
+        }
+
+        Clara::CommandLine<ConfigData> m_cli;
+        std::vector<Clara::Parser::Token> m_unusedTokens;
+        ConfigData m_configData;
+        Ptr<Config> m_config;
+    };
+
+    bool Session::alreadyInstantiated = false;
+
+} // end namespace Catch
+
+// #included from: catch_registry_hub.hpp
+#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
+
+// #included from: catch_test_case_registry_impl.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <set>
+#include <sstream>
+#include <algorithm>
+
+namespace Catch {
+
+    struct RandomNumberGenerator {
+        typedef unsigned int result_type;
+
+        result_type operator()( result_type n ) const { return std::rand() % n; }
+
+#ifdef CATCH_CONFIG_CPP11_SHUFFLE
+        static constexpr result_type (min)() { return 0; }
+        static constexpr result_type (max)() { return 1000000; }
+        result_type operator()() const { return std::rand() % (max)(); }
+#endif
+        template<typename V>
+        static void shuffle( V& vector ) {
+            RandomNumberGenerator rng;
+#ifdef CATCH_CONFIG_CPP11_SHUFFLE
+            std::shuffle( vector.begin(), vector.end(), rng );
+#else
+            std::random_shuffle( vector.begin(), vector.end(), rng );
+#endif
+        }
+    };
+
+    inline std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+
+        std::vector<TestCase> sorted = unsortedTestCases;
+
+        switch( config.runOrder() ) {
+            case RunTests::InLexicographicalOrder:
+                std::sort( sorted.begin(), sorted.end() );
+                break;
+            case RunTests::InRandomOrder:
+                {
+                    seedRng( config );
+                    RandomNumberGenerator::shuffle( sorted );
+                }
+                break;
+            case RunTests::InDeclarationOrder:
+                // already in declaration order
+                break;
+        }
+        return sorted;
+    }
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
+    }
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+        std::set<TestCase> seenFunctions;
+        for( std::vector<TestCase>::const_iterator it = functions.begin(), itEnd = functions.end();
+            it != itEnd;
+            ++it ) {
+            std::pair<std::set<TestCase>::const_iterator, bool> prev = seenFunctions.insert( *it );
+            if( !prev.second ) {
+                std::ostringstream ss;
+
+                ss  << Colour( Colour::Red )
+                    << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n"
+                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << '\n'
+                    << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl;
+
+                throw std::runtime_error(ss.str());
+            }
+        }
+    }
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCase> filtered;
+        filtered.reserve( testCases.size() );
+        for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
+                it != itEnd;
+                ++it )
+            if( matchTest( *it, testSpec, config ) )
+                filtered.push_back( *it );
+        return filtered;
+    }
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        TestRegistry()
+        :   m_currentSortOrder( RunTests::InDeclarationOrder ),
+            m_unnamedCount( 0 )
+        {}
+        virtual ~TestRegistry();
+
+        virtual void registerTest( TestCase const& testCase ) {
+            std::string name = testCase.getTestCaseInfo().name;
+            if( name.empty() ) {
+                std::ostringstream oss;
+                oss << "Anonymous test case " << ++m_unnamedCount;
+                return registerTest( testCase.withName( oss.str() ) );
+            }
+            m_functions.push_back( testCase );
+        }
+
+        virtual std::vector<TestCase> const& getAllTests() const {
+            return m_functions;
+        }
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const {
+            if( m_sortedFunctions.empty() )
+                enforceNoDuplicateTestCases( m_functions );
+
+            if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+                m_sortedFunctions = sortTests( config, m_functions );
+                m_currentSortOrder = config.runOrder();
+            }
+            return m_sortedFunctions;
+        }
+
+    private:
+        std::vector<TestCase> m_functions;
+        mutable RunTests::InWhatOrder m_currentSortOrder;
+        mutable std::vector<TestCase> m_sortedFunctions;
+        size_t m_unnamedCount;
+        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
+    public:
+
+        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
+
+        virtual void invoke() const {
+            m_fun();
+        }
+
+    private:
+        virtual ~FreeFunctionTestCase();
+
+        TestFunction m_fun;
+    };
+
+    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
+        std::string className = classOrQualifiedMethodName;
+        if( startsWith( className, '&' ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+    void registerTestCase
+        (   ITestCase* testCase,
+            char const* classOrQualifiedMethodName,
+            NameAndDesc const& nameAndDesc,
+            SourceLineInfo const& lineInfo ) {
+
+        getMutableRegistryHub().registerTest
+            ( makeTestCase
+                (   testCase,
+                    extractClassName( classOrQualifiedMethodName ),
+                    nameAndDesc.name,
+                    nameAndDesc.description,
+                    lineInfo ) );
+    }
+    void registerTestCaseFunction
+        (   TestFunction function,
+            SourceLineInfo const& lineInfo,
+            NameAndDesc const& nameAndDesc ) {
+        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    AutoReg::AutoReg
+        (   TestFunction function,
+            SourceLineInfo const& lineInfo,
+            NameAndDesc const& nameAndDesc ) {
+        registerTestCaseFunction( function, lineInfo, nameAndDesc );
+    }
+
+    AutoReg::~AutoReg() {}
+
+} // end namespace Catch
+
+// #included from: catch_reporter_registry.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        virtual ~ReporterRegistry() CATCH_OVERRIDE {}
+
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
+            FactoryMap::const_iterator it =  m_factories.find( name );
+            if( it == m_factories.end() )
+                return CATCH_NULL;
+            return it->second->create( ReporterConfig( config ) );
+        }
+
+        void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) {
+            m_factories.insert( std::make_pair( name, factory ) );
+        }
+        void registerListener( Ptr<IReporterFactory> const& factory ) {
+            m_listeners.push_back( factory );
+        }
+
+        virtual FactoryMap const& getFactories() const CATCH_OVERRIDE {
+            return m_factories;
+        }
+        virtual Listeners const& getListeners() const CATCH_OVERRIDE {
+            return m_listeners;
+        }
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+// #included from: catch_exception_translator_registry.hpp
+#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry() {
+            deleteAll( m_translators );
+        }
+
+        virtual void registerTranslator( const IExceptionTranslator* translator ) {
+            m_translators.push_back( translator );
+        }
+
+        virtual std::string translateActiveException() const {
+            try {
+#ifdef __OBJC__
+                // In Objective-C try objective-c exceptions first
+                @try {
+                    return tryTranslators();
+                }
+                @catch (NSException *exception) {
+                    return Catch::toString( [exception description] );
+                }
+#else
+                return tryTranslators();
+#endif
+            }
+            catch( TestFailureException& ) {
+                throw;
+            }
+            catch( std::exception& ex ) {
+                return ex.what();
+            }
+            catch( std::string& msg ) {
+                return msg;
+            }
+            catch( const char* msg ) {
+                return msg;
+            }
+            catch(...) {
+                return "Unknown exception";
+            }
+        }
+
+        std::string tryTranslators() const {
+            if( m_translators.empty() )
+                throw;
+            else
+                return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
+        }
+
+    private:
+        std::vector<const IExceptionTranslator*> m_translators;
+    };
+}
+
+// #included from: catch_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        virtual ~TagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
+
+            RegistryHub( RegistryHub const& );
+            void operator=( RegistryHub const& );
+
+        public: // IRegistryHub
+            RegistryHub() {
+            }
+            virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE {
+                return m_reporterRegistry;
+            }
+            virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE {
+                return m_testCaseRegistry;
+            }
+            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE {
+                return m_exceptionTranslatorRegistry;
+            }
+            virtual ITagAliasRegistry const& getTagAliasRegistry() const CATCH_OVERRIDE {
+                return m_tagAliasRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            virtual void registerListener( Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
+                m_reporterRegistry.registerListener( factory );
+            }
+            virtual void registerTest( TestCase const& testInfo ) CATCH_OVERRIDE {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+            virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) CATCH_OVERRIDE {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+        };
+
+        // Single, global, instance
+        inline RegistryHub*& getTheRegistryHub() {
+            static RegistryHub* theRegistryHub = CATCH_NULL;
+            if( !theRegistryHub )
+                theRegistryHub = new RegistryHub();
+            return theRegistryHub;
+        }
+    }
+
+    IRegistryHub& getRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    void cleanUp() {
+        delete getTheRegistryHub();
+        getTheRegistryHub() = CATCH_NULL;
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_notimplemented_exception.hpp
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
+
+#include <sstream>
+
+namespace Catch {
+
+    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
+    :   m_lineInfo( lineInfo ) {
+        std::ostringstream oss;
+        oss << lineInfo << ": function ";
+        oss << "not implemented";
+        m_what = oss.str();
+    }
+
+    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
+        return m_what.c_str();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_context_impl.hpp
+#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
+
+// #included from: catch_stream.hpp
+#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
+
+#include <stdexcept>
+#include <cstdio>
+#include <iostream>
+
+namespace Catch {
+
+    template<typename WriterF, size_t bufferSize=256>
+    class StreamBufImpl : public StreamBufBase {
+        char data[bufferSize];
+        WriterF m_writer;
+
+    public:
+        StreamBufImpl() {
+            setp( data, data + sizeof(data) );
+        }
+
+        ~StreamBufImpl() CATCH_NOEXCEPT {
+            sync();
+        }
+
+    private:
+        int overflow( int c ) {
+            sync();
+
+            if( c != EOF ) {
+                if( pbase() == epptr() )
+                    m_writer( std::string( 1, static_cast<char>( c ) ) );
+                else
+                    sputc( static_cast<char>( c ) );
+            }
+            return 0;
+        }
+
+        int sync() {
+            if( pbase() != pptr() ) {
+                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                setp( pbase(), epptr() );
+            }
+            return 0;
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    FileStream::FileStream( std::string const& filename ) {
+        m_ofs.open( filename.c_str() );
+        if( m_ofs.fail() ) {
+            std::ostringstream oss;
+            oss << "Unable to open file: '" << filename << '\'';
+            throw std::domain_error( oss.str() );
+        }
+    }
+
+    std::ostream& FileStream::stream() const {
+        return m_ofs;
+    }
+
+    struct OutputDebugWriter {
+
+        void operator()( std::string const&str ) {
+            writeToDebugConsole( str );
+        }
+    };
+
+    DebugOutStream::DebugOutStream()
+    :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+        m_os( m_streamBuf.get() )
+    {}
+
+    std::ostream& DebugOutStream::stream() const {
+        return m_os;
+    }
+
+    // Store the streambuf from cout up-front because
+    // cout may get redirected when running tests
+    CoutStream::CoutStream()
+    :   m_os( Catch::cout().rdbuf() )
+    {}
+
+    std::ostream& CoutStream::stream() const {
+        return m_os;
+    }
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+    std::ostream& cout() {
+        return std::cout;
+    }
+    std::ostream& cerr() {
+        return std::cerr;
+    }
+    std::ostream& clog() {
+        return std::clog;
+    }
+#endif
+}
+
+namespace Catch {
+
+    class Context : public IMutableContext {
+
+        Context() : m_config( CATCH_NULL ), m_runner( CATCH_NULL ), m_resultCapture( CATCH_NULL ) {}
+        Context( Context const& );
+        void operator=( Context const& );
+
+    public:
+        virtual ~Context() {
+            deleteAllValues( m_generatorsByTestName );
+        }
+
+    public: // IContext
+        virtual IResultCapture* getResultCapture() {
+            return m_resultCapture;
+        }
+        virtual IRunner* getRunner() {
+            return m_runner;
+        }
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
+            return getGeneratorsForCurrentTest()
+            .getGeneratorInfo( fileInfo, totalSize )
+            .getCurrentIndex();
+        }
+        virtual bool advanceGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            return generators && generators->moveNext();
+        }
+
+        virtual Ptr<IConfig const> getConfig() const {
+            return m_config;
+        }
+
+    public: // IMutableContext
+        virtual void setResultCapture( IResultCapture* resultCapture ) {
+            m_resultCapture = resultCapture;
+        }
+        virtual void setRunner( IRunner* runner ) {
+            m_runner = runner;
+        }
+        virtual void setConfig( Ptr<IConfig const> const& config ) {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IGeneratorsForTest* findGeneratorsForCurrentTest() {
+            std::string testName = getResultCapture()->getCurrentTestName();
+
+            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
+                m_generatorsByTestName.find( testName );
+            return it != m_generatorsByTestName.end()
+                ? it->second
+                : CATCH_NULL;
+        }
+
+        IGeneratorsForTest& getGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            if( !generators ) {
+                std::string testName = getResultCapture()->getCurrentTestName();
+                generators = createGeneratorsForTest();
+                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
+            }
+            return *generators;
+        }
+
+    private:
+        Ptr<IConfig const> m_config;
+        IRunner* m_runner;
+        IResultCapture* m_resultCapture;
+        std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
+    };
+
+    namespace {
+        Context* currentContext = CATCH_NULL;
+    }
+    IMutableContext& getCurrentMutableContext() {
+        if( !currentContext )
+            currentContext = new Context();
+        return *currentContext;
+    }
+    IContext& getCurrentContext() {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext() {
+        delete currentContext;
+        currentContext = CATCH_NULL;
+    }
+}
+
+// #included from: catch_console_colour_impl.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
+
+// #included from: catch_errno_guard.hpp
+#define TWOBLUECUBES_CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+#include <cerrno>
+
+namespace Catch {
+
+    class ErrnoGuard {
+    public:
+        ErrnoGuard():m_oldErrno(errno){}
+        ~ErrnoGuard() { errno = m_oldErrno; }
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+namespace Catch {
+    namespace {
+
+        struct IColourImpl {
+            virtual ~IColourImpl() {}
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
+        }
+        HANDLE stdoutHandle;
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+    IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+
+        Ptr<IConfig const> config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = !isDebuggerActive()
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? &s_instance
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public IColourImpl {
+    public:
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0;34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
+    private:
+        void setColour( const char* _escapeCode ) {
+            Catch::cout() << '\033' << _escapeCode;
+        }
+    };
+
+    IColourImpl* platformColourInstance() {
+        ErrnoGuard guard;
+        Ptr<IConfig const> config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) )
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
+    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = platformColourInstance();
+        impl->use( _colourCode );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_generators_impl.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <string>
+#include <map>
+
+namespace Catch {
+
+    struct GeneratorInfo : IGeneratorInfo {
+
+        GeneratorInfo( std::size_t size )
+        :   m_size( size ),
+            m_currentIndex( 0 )
+        {}
+
+        bool moveNext() {
+            if( ++m_currentIndex == m_size ) {
+                m_currentIndex = 0;
+                return false;
+            }
+            return true;
+        }
+
+        std::size_t getCurrentIndex() const {
+            return m_currentIndex;
+        }
+
+        std::size_t m_size;
+        std::size_t m_currentIndex;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class GeneratorsForTest : public IGeneratorsForTest {
+
+    public:
+        ~GeneratorsForTest() {
+            deleteAll( m_generatorsInOrder );
+        }
+
+        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
+            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
+            if( it == m_generatorsByName.end() ) {
+                IGeneratorInfo* info = new GeneratorInfo( size );
+                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
+                m_generatorsInOrder.push_back( info );
+                return *info;
+            }
+            return *it->second;
+        }
+
+        bool moveNext() {
+            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
+            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
+            for(; it != itEnd; ++it ) {
+                if( (*it)->moveNext() )
+                    return true;
+            }
+            return false;
+        }
+
+    private:
+        std::map<std::string, IGeneratorInfo*> m_generatorsByName;
+        std::vector<IGeneratorInfo*> m_generatorsInOrder;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest()
+    {
+        return new GeneratorsForTest();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.hpp
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
+
+namespace Catch {
+
+    AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){}
+
+    AssertionInfo::AssertionInfo(   char const * _macroName,
+                                    SourceLineInfo const& _lineInfo,
+                                    char const * _capturedExpression,
+                                    ResultDisposition::Flags _resultDisposition,
+                                    char const * _secondArg)
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        capturedExpression( _capturedExpression ),
+        resultDisposition( _resultDisposition ),
+        secondArg( _secondArg )
+    {}
+
+    AssertionResult::AssertionResult() {}
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    AssertionResult::~AssertionResult() {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return m_info.capturedExpression[0] != 0;
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) {
+        return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"')
+            ? capturedExpression
+            : std::string(capturedExpression) + ", " + secondArg;
+    }
+
+    std::string AssertionResult::getExpression() const {
+        if( isFalseTest( m_info.resultDisposition ) )
+            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
+        else
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+    }
+    std::string AssertionResult::getExpressionInMacro() const {
+        if( m_info.macroName[0] == 0 )
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+        else
+            return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )";
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        return m_resultData.reconstructExpression();
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    std::string AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+    void AssertionResult::discardDecomposedExpression() const {
+        m_resultData.decomposedExpression = CATCH_NULL;
+    }
+
+    void AssertionResult::expandDecomposedExpression() const {
+        m_resultData.reconstructExpression();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_test_case_info.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+#include <cctype>
+
+namespace Catch {
+
+    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+        if( startsWith( tag, '.' ) ||
+            tag == "hide" ||
+            tag == "!hide" )
+            return TestCaseInfo::IsHidden;
+        else if( tag == "!throws" )
+            return TestCaseInfo::Throws;
+        else if( tag == "!shouldfail" )
+            return TestCaseInfo::ShouldFail;
+        else if( tag == "!mayfail" )
+            return TestCaseInfo::MayFail;
+        else if( tag == "!nonportable" )
+            return TestCaseInfo::NonPortable;
+        else
+            return TestCaseInfo::None;
+    }
+    inline bool isReservedTag( std::string const& tag ) {
+        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( tag[0] );
+    }
+    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+        if( isReservedTag( tag ) ) {
+            std::ostringstream ss;
+            ss << Colour(Colour::Red)
+               << "Tag name [" << tag << "] not allowed.\n"
+               << "Tag names starting with non alpha-numeric characters are reserved\n"
+               << Colour(Colour::FileName)
+               << _lineInfo << '\n';
+            throw std::runtime_error(ss.str());
+        }
+    }
+
+    TestCase makeTestCase(  ITestCase* _testCase,
+                            std::string const& _className,
+                            std::string const& _name,
+                            std::string const& _descOrTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden( startsWith( _name, "./" ) ); // Legacy support
+
+        // Parse out tags
+        std::set<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
+            char c = _descOrTags[i];
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( prop == TestCaseInfo::IsHidden )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    tags.insert( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            tags.insert( "hide" );
+            tags.insert( "." );
+        }
+
+        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, info );
+    }
+
+    void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags )
+    {
+        testCaseInfo.tags = tags;
+        testCaseInfo.lcaseTags.clear();
+
+        std::ostringstream oss;
+        for( std::set<std::string>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) {
+            oss << '[' << *it << ']';
+            std::string lcaseTag = toLower( *it );
+            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+            testCaseInfo.lcaseTags.insert( lcaseTag );
+        }
+        testCaseInfo.tagsAsString = oss.str();
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::set<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        setTags( *this, _tags );
+    }
+
+    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
+    :   name( other.name ),
+        className( other.className ),
+        description( other.description ),
+        tags( other.tags ),
+        lcaseTags( other.lcaseTags ),
+        tagsAsString( other.tagsAsString ),
+        lineInfo( other.lineInfo ),
+        properties( other.properties )
+    {}
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
+
+    TestCase::TestCase( TestCase const& other )
+    :   TestCaseInfo( other ),
+        test( other.test )
+    {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::swap( TestCase& other ) {
+        test.swap( other.test );
+        name.swap( other.name );
+        className.swap( other.className );
+        description.swap( other.description );
+        tags.swap( other.tags );
+        lcaseTags.swap( other.lcaseTags );
+        tagsAsString.swap( other.tagsAsString );
+        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
+        std::swap( lineInfo, other.lineInfo );
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+    TestCase& TestCase::operator = ( TestCase const& other ) {
+        TestCase temp( other );
+        swap( temp );
+        return *this;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_version.hpp
+#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    inline Version libraryVersion() {
+        static Version version( 1, 12, 1, "", 0 );
+        return version;
+    }
+
+}
+
+// #included from: catch_message.hpp
+#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   std::string const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info )
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+    ScopedMessage::ScopedMessage( ScopedMessage const& other )
+    : m_info( other.m_info )
+    {}
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
+#endif
+    ScopedMessage::~ScopedMessage() {
+        if ( !std::uncaught_exception() ){
+            getResultCapture().popScopedMessage(m_info);
+        }
+    }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+} // end namespace Catch
+
+// #included from: catch_legacy_reporter_adapter.hpp
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
+
+// #included from: catch_legacy_reporter_adapter.h
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
+
+namespace Catch
+{
+    // Deprecated
+    struct IReporter : IShared {
+        virtual ~IReporter();
+
+        virtual bool shouldRedirectStdout() const = 0;
+
+        virtual void StartTesting() = 0;
+        virtual void EndTesting( Totals const& totals ) = 0;
+        virtual void StartGroup( std::string const& groupName ) = 0;
+        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
+        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
+        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
+        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
+        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
+        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
+        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
+        virtual void Aborted() = 0;
+        virtual void Result( AssertionResult const& result ) = 0;
+    };
+
+    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
+    {
+    public:
+        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
+        virtual ~LegacyReporterAdapter();
+
+        virtual ReporterPreferences getPreferences() const;
+        virtual void noMatchingTestCases( std::string const& );
+        virtual void testRunStarting( TestRunInfo const& );
+        virtual void testGroupStarting( GroupInfo const& groupInfo );
+        virtual void testCaseStarting( TestCaseInfo const& testInfo );
+        virtual void sectionStarting( SectionInfo const& sectionInfo );
+        virtual void assertionStarting( AssertionInfo const& );
+        virtual bool assertionEnded( AssertionStats const& assertionStats );
+        virtual void sectionEnded( SectionStats const& sectionStats );
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
+        virtual void testRunEnded( TestRunStats const& testRunStats );
+        virtual void skipTest( TestCaseInfo const& );
+
+    private:
+        Ptr<IReporter> m_legacyReporter;
+    };
+}
+
+namespace Catch
+{
+    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
+    :   m_legacyReporter( legacyReporter )
+    {}
+    LegacyReporterAdapter::~LegacyReporterAdapter() {}
+
+    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
+        ReporterPreferences prefs;
+        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
+        return prefs;
+    }
+
+    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
+    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
+        m_legacyReporter->StartTesting();
+    }
+    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
+        m_legacyReporter->StartGroup( groupInfo.name );
+    }
+    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        m_legacyReporter->StartTestCase( testInfo );
+    }
+    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
+        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
+    }
+    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
+        // Not on legacy interface
+    }
+
+    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
+            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                    it != itEnd;
+                    ++it ) {
+                if( it->type == ResultWas::Info ) {
+                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
+                    rb << it->message;
+                    rb.setResultType( ResultWas::Info );
+                    AssertionResult result = rb.build();
+                    m_legacyReporter->Result( result );
+                }
+            }
+        }
+        m_legacyReporter->Result( assertionStats.assertionResult );
+        return true;
+    }
+    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
+        if( sectionStats.missingAssertions )
+            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
+        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
+    }
+    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        m_legacyReporter->EndTestCase
+            (   testCaseStats.testInfo,
+                testCaseStats.totals,
+                testCaseStats.stdOut,
+                testCaseStats.stdErr );
+    }
+    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        if( testGroupStats.aborting )
+            m_legacyReporter->Aborted();
+        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
+    }
+    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
+        m_legacyReporter->EndTesting( testRunStats.totals );
+    }
+    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
+    }
+}
+
+// #included from: catch_timer.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#endif
+
+#ifdef CATCH_PLATFORM_WINDOWS
+
+#else
+
+#include <sys/time.h>
+
+#endif
+
+namespace Catch {
+
+    namespace {
+#ifdef CATCH_PLATFORM_WINDOWS
+        UInt64 getCurrentTicks() {
+            static UInt64 hz=0, hzo=0;
+            if (!hz) {
+                QueryPerformanceFrequency( reinterpret_cast<LARGE_INTEGER*>( &hz ) );
+                QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &hzo ) );
+            }
+            UInt64 t;
+            QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &t ) );
+            return ((t-hzo)*1000000)/hz;
+        }
+#else
+        UInt64 getCurrentTicks() {
+            timeval t;
+            gettimeofday(&t,CATCH_NULL);
+            return static_cast<UInt64>( t.tv_sec ) * 1000000ull + static_cast<UInt64>( t.tv_usec );
+        }
+#endif
+    }
+
+    void Timer::start() {
+        m_ticks = getCurrentTicks();
+    }
+    unsigned int Timer::getElapsedMicroseconds() const {
+        return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
+    }
+    unsigned int Timer::getElapsedMilliseconds() const {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    double Timer::getElapsedSeconds() const {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// #included from: catch_common.hpp
+#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
+
+#include <cstring>
+#include <cctype>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( std::string const& s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    char toLowerCh(char c) {
+        return static_cast<char>( std::tolower( c ) );
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+    SourceLineInfo::SourceLineInfo() : file(""), line( 0 ){}
+    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
+    :   file( _file ),
+        line( _line )
+    {}
+    bool SourceLineInfo::empty() const {
+        return file[0] == '\0';
+    }
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const {
+        return line < other.line || ( line == other.line && (std::strcmp(file, other.file) < 0));
+    }
+
+    void seedRng( IConfig const& config ) {
+        if( config.rngSeed() != 0 )
+            std::srand( config.rngSeed() );
+    }
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
+        std::ostringstream oss;
+        oss << locationInfo << ": Internal Catch error: '" << message << '\'';
+        if( alwaysTrue() )
+            throw std::logic_error( oss.str() );
+    }
+}
+
+// #included from: catch_section.hpp
+#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name,
+            std::string const& _description )
+    :   name( _name ),
+        description( _description ),
+        lineInfo( _lineInfo )
+    {}
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
+#endif
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
+            if( std::uncaught_exception() )
+                getResultCapture().sectionEndedEarly( endInfo );
+            else
+                getResultCapture().sectionEnded( endInfo );
+        }
+    }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_debugger.hpp
+#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #include <assert.h>
+    #include <stdbool.h>
+    #include <sys/types.h>
+    #include <unistd.h>
+    #include <sys/sysctl.h>
+
+    namespace Catch{
+
+        // The following function is taken directly from the following technical note:
+        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+
+            int                 mib[4];
+            struct kinfo_proc   info;
+            size_t              size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+    } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    #include <fstream>
+    #include <string>
+
+    namespace Catch{
+        // The standard POSIX way of detecting a debugger is to attempt to
+        // ptrace() the process, but this needs to be done from a child and not
+        // this process itself to still allow attaching to this process later
+        // if wanted, so is rather heavy. Under Linux we have the PID of the
+        // "debugger" (which doesn't need to be gdb, of course, it could also
+        // be strace, for example) in /proc/$PID/status, so just get it from
+        // there instead.
+        bool isDebuggerActive(){
+            // Libstdc++ has a bug, where std::ifstream sets errno to 0
+            // This way our users can properly assert over errno values
+            ErrnoGuard guard;
+            std::ifstream in("/proc/self/status");
+            for( std::string line; std::getline(in, line); ) {
+                static const int PREFIX_LEN = 11;
+                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+                    // We're traced if the PID is not 0 and no other PID starts
+                    // with 0 digit, so it's enough to check for just a single
+                    // character.
+                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+                }
+            }
+
+            return false;
+        }
+    } // namespace Catch
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       inline bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+
+#ifdef CATCH_PLATFORM_WINDOWS
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+#else
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+#endif // Platform
+
+// #included from: catch_tostring.hpp
+#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
+
+namespace Catch {
+
+namespace Detail {
+
+    const std::string unprintableString = "{?}";
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                union _{
+                    int asInt;
+                    char asChar[sizeof (int)];
+                } u;
+
+                u.asInt = 1;
+                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size )
+    {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        std::ostringstream os;
+        os << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return os.str();
+    }
+}
+
+std::string toString( std::string const& value ) {
+    std::string s = value;
+    if( getCurrentContext().getConfig()->showInvisibles() ) {
+        for(size_t i = 0; i < s.size(); ++i ) {
+            std::string subs;
+            switch( s[i] ) {
+            case '\n': subs = "\\n"; break;
+            case '\t': subs = "\\t"; break;
+            default: break;
+            }
+            if( !subs.empty() ) {
+                s = s.substr( 0, i ) + subs + s.substr( i+1 );
+                ++i;
+            }
+        }
+    }
+    return '"' + s + '"';
+}
+std::string toString( std::wstring const& value ) {
+
+    std::string s;
+    s.reserve( value.size() );
+    for(size_t i = 0; i < value.size(); ++i )
+        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
+    return Catch::toString( s );
+}
+
+std::string toString( const char* const value ) {
+    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
+}
+
+std::string toString( char* const value ) {
+    return Catch::toString( static_cast<const char*>( value ) );
+}
+
+std::string toString( const wchar_t* const value )
+{
+    return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
+}
+
+std::string toString( wchar_t* const value )
+{
+    return Catch::toString( static_cast<const wchar_t*>( value ) );
+}
+
+std::string toString( int value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+
+std::string toString( unsigned long value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+
+std::string toString( unsigned int value ) {
+    return Catch::toString( static_cast<unsigned long>( value ) );
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    std::ostringstream oss;
+    oss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = oss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+std::string toString( const double value ) {
+    return fpToString( value, 10 );
+}
+std::string toString( const float value ) {
+    return fpToString( value, 5 ) + 'f';
+}
+
+std::string toString( bool value ) {
+    return value ? "true" : "false";
+}
+
+std::string toString( char value ) {
+    if ( value == '\r' )
+        return "'\\r'";
+    if ( value == '\f' )
+        return "'\\f'";
+    if ( value == '\n' )
+        return "'\\n'";
+    if ( value == '\t' )
+        return "'\\t'";
+    if ( '\0' <= value && value < ' ' )
+        return toString( static_cast<unsigned int>( value ) );
+    char chstr[] = "' '";
+    chstr[1] = value;
+    return chstr;
+}
+
+std::string toString( signed char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+std::string toString( unsigned char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+std::string toString( long long value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+std::string toString( unsigned long long value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t ) {
+    return "nullptr";
+}
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSObject* const& nsObject ) {
+        return toString( [nsObject description] );
+    }
+#endif
+
+} // end namespace Catch
+
+// #included from: catch_result_builder.hpp
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
+
+namespace Catch {
+
+    ResultBuilder::ResultBuilder(   char const* macroName,
+                                    SourceLineInfo const& lineInfo,
+                                    char const* capturedExpression,
+                                    ResultDisposition::Flags resultDisposition,
+                                    char const* secondArg )
+    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition, secondArg ),
+        m_shouldDebugBreak( false ),
+        m_shouldThrow( false ),
+        m_guardException( false ),
+        m_usedStream( false )
+    {}
+
+    ResultBuilder::~ResultBuilder() {
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+        if ( m_guardException ) {
+            stream().oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+            captureResult( ResultWas::ThrewException );
+            getCurrentContext().getResultCapture()->exceptionEarlyReported();
+        }
+#endif
+    }
+
+    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
+        m_data.resultType = result;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setResultType( bool result ) {
+        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
+        return *this;
+    }
+
+    void ResultBuilder::endExpression( DecomposedExpression const& expr ) {
+        // Flip bool results if FalseTest flag is set
+        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
+            m_data.negate( expr.isBinaryExpression() );
+        }
+
+        getResultCapture().assertionRun();
+
+        if(getCurrentContext().getConfig()->includeSuccessfulResults() || m_data.resultType != ResultWas::Ok)
+        {
+            AssertionResult result = build( expr );
+            handleResult( result );
+        }
+        else
+            getResultCapture().assertionPassed();
+    }
+
+    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
+        m_assertionInfo.resultDisposition = resultDisposition;
+        stream().oss << Catch::translateActiveException();
+        captureResult( ResultWas::ThrewException );
+    }
+
+    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
+        setResultType( resultType );
+        captureExpression();
+    }
+
+    void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) {
+        if( expectedMessage.empty() )
+            captureExpectedException( Matchers::Impl::MatchAllOf<std::string>() );
+        else
+            captureExpectedException( Matchers::Equals( expectedMessage ) );
+    }
+
+    void ResultBuilder::captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher ) {
+
+        assert( !isFalseTest( m_assertionInfo.resultDisposition ) );
+        AssertionResultData data = m_data;
+        data.resultType = ResultWas::Ok;
+        data.reconstructedExpression = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
+
+        std::string actualMessage = Catch::translateActiveException();
+        if( !matcher.match( actualMessage ) ) {
+            data.resultType = ResultWas::ExpressionFailed;
+            data.reconstructedExpression = actualMessage;
+        }
+        AssertionResult result( m_assertionInfo, data );
+        handleResult( result );
+    }
+
+    void ResultBuilder::captureExpression() {
+        AssertionResult result = build();
+        handleResult( result );
+    }
+
+    void ResultBuilder::handleResult( AssertionResult const& result )
+    {
+        getResultCapture().assertionEnded( result );
+
+        if( !result.isOk() ) {
+            if( getCurrentContext().getConfig()->shouldDebugBreak() )
+                m_shouldDebugBreak = true;
+            if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) )
+                m_shouldThrow = true;
+        }
+    }
+
+    void ResultBuilder::react() {
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+        if (m_shouldDebugBreak) {
+            ///////////////////////////////////////////////////////////////////
+            // To inspect the state during test, you need to go one level up the callstack
+            // To go back to the test and change execution, jump over the throw statement
+            ///////////////////////////////////////////////////////////////////
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+#endif
+        if( m_shouldThrow )
+            throw Catch::TestFailureException();
+    }
+
+    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
+    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
+
+    AssertionResult ResultBuilder::build() const
+    {
+        return build( *this );
+    }
+
+    // CAVEAT: The returned AssertionResult stores a pointer to the argument expr,
+    //         a temporary DecomposedExpression, which in turn holds references to
+    //         operands, possibly temporary as well.
+    //         It should immediately be passed to handleResult; if the expression
+    //         needs to be reported, its string expansion must be composed before
+    //         the temporaries are destroyed.
+    AssertionResult ResultBuilder::build( DecomposedExpression const& expr ) const
+    {
+        assert( m_data.resultType != ResultWas::Unknown );
+        AssertionResultData data = m_data;
+
+        if(m_usedStream)
+            data.message = m_stream().oss.str();
+        data.decomposedExpression = &expr; // for lazy reconstruction
+        return AssertionResult( m_assertionInfo, data );
+    }
+
+    void ResultBuilder::reconstructExpression( std::string& dest ) const {
+        dest = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
+    }
+
+    void ResultBuilder::setExceptionGuard() {
+        m_guardException = true;
+    }
+    void ResultBuilder::unsetExceptionGuard() {
+        m_guardException = false;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_tag_alias_registry.hpp
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
+        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return it->second;
+        else
+            return Option<TagAlias>();
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
+                it != itEnd;
+                ++it ) {
+            std::size_t pos = expandedTestSpec.find( it->first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    it->second.tag +
+                                    expandedTestSpec.substr( pos + it->first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+
+        if( !startsWith( alias, "[@" ) || !endsWith( alias, ']' ) ) {
+            std::ostringstream oss;
+            oss << Colour( Colour::Red )
+                << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n"
+                << Colour( Colour::FileName )
+                << lineInfo << '\n';
+            throw std::domain_error( oss.str().c_str() );
+        }
+        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
+            std::ostringstream oss;
+            oss << Colour( Colour::Red )
+                << "error: tag alias, \"" << alias << "\" already registered.\n"
+                << "\tFirst seen at "
+                << Colour( Colour::Red ) << find(alias)->lineInfo << '\n'
+                << Colour( Colour::Red ) << "\tRedefined at "
+                << Colour( Colour::FileName) << lineInfo << '\n';
+            throw std::domain_error( oss.str().c_str() );
+        }
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
+        getMutableRegistryHub().registerTagAlias( alias, tag, lineInfo );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_matchers_string.hpp
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_str( adjustString( str ) )
+        {}
+        std::string CasedString::adjustString( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? toLower( str )
+                   : str;
+        }
+        std::string CasedString::caseSensitivitySuffix() const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? " (case insensitive)"
+                   : std::string();
+        }
+
+        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
+        : m_comparator( comparator ),
+          m_operation( operation ) {
+        }
+
+        std::string StringMatcherBase::describe() const {
+            std::string description;
+            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                        m_comparator.caseSensitivitySuffix().size());
+            description += m_operation;
+            description += ": \"";
+            description += m_comparator.m_str;
+            description += "\"";
+            description += m_comparator.caseSensitivitySuffix();
+            return description;
+        }
+
+        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+        bool EqualsMatcher::match( std::string const& source ) const {
+            return m_comparator.adjustString( source ) == m_comparator.m_str;
+        }
+
+        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+        bool ContainsMatcher::match( std::string const& source ) const {
+            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
+
+        bool StartsWithMatcher::match( std::string const& source ) const {
+            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+        bool EndsWithMatcher::match( std::string const& source ) const {
+            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+    } // namespace StdString
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+
+} // namespace Matchers
+} // namespace Catch
+// #included from: ../reporters/catch_reporter_multi.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+namespace Catch {
+
+class MultipleReporters : public SharedImpl<IStreamingReporter> {
+    typedef std::vector<Ptr<IStreamingReporter> > Reporters;
+    Reporters m_reporters;
+
+public:
+    void add( Ptr<IStreamingReporter> const& reporter ) {
+        m_reporters.push_back( reporter );
+    }
+
+public: // IStreamingReporter
+
+    virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
+        return m_reporters[0]->getPreferences();
+    }
+
+    virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->noMatchingTestCases( spec );
+    }
+
+    virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testRunStarting( testRunInfo );
+    }
+
+    virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testGroupStarting( groupInfo );
+    }
+
+    virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testCaseStarting( testInfo );
+    }
+
+    virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->sectionStarting( sectionInfo );
+    }
+
+    virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->assertionStarting( assertionInfo );
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+        bool clearBuffer = false;
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            clearBuffer |= (*it)->assertionEnded( assertionStats );
+        return clearBuffer;
+    }
+
+    virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->sectionEnded( sectionStats );
+    }
+
+    virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testCaseEnded( testCaseStats );
+    }
+
+    virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testGroupEnded( testGroupStats );
+    }
+
+    virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testRunEnded( testRunStats );
+    }
+
+    virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->skipTest( testInfo );
+    }
+
+    virtual MultipleReporters* tryAsMulti() CATCH_OVERRIDE {
+        return this;
+    }
+
+};
+
+Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
+    Ptr<IStreamingReporter> resultingReporter;
+
+    if( existingReporter ) {
+        MultipleReporters* multi = existingReporter->tryAsMulti();
+        if( !multi ) {
+            multi = new MultipleReporters;
+            resultingReporter = Ptr<IStreamingReporter>( multi );
+            if( existingReporter )
+                multi->add( existingReporter );
+        }
+        else
+            resultingReporter = existingReporter;
+        multi->add( additionalReporter );
+    }
+    else
+        resultingReporter = additionalReporter;
+
+    return resultingReporter;
+}
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_xml.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
+
+// #included from: catch_reporter_bases.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
+
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <assert.h>
+
+namespace Catch {
+
+    namespace {
+        // Because formatting using c++ streams is stateful, drop down to C is required
+        // Alternatively we could use stringstream, but its performance is... not good.
+        std::string getFormattedDuration( double duration ) {
+            // Max exponent + 1 is required to represent the whole part
+            // + 1 for decimal point
+            // + 3 for the 3 decimal places
+            // + 1 for null terminator
+            const size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+            char buffer[maxDoubleSize];
+
+            // Save previous errno, to prevent sprintf from overwriting it
+            ErrnoGuard guard;
+#ifdef _MSC_VER
+            sprintf_s(buffer, "%.3f", duration);
+#else
+            sprintf(buffer, "%.3f", duration);
+#endif
+            return std::string(buffer);
+        }
+    }
+
+    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+        }
+
+        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
+            return m_reporterPrefs;
+        }
+
+        virtual ~StreamingReporterBase() CATCH_OVERRIDE;
+
+        virtual void noMatchingTestCases( std::string const& ) CATCH_OVERRIDE {}
+
+        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) CATCH_OVERRIDE {
+            currentTestRunInfo = _testRunInfo;
+        }
+        virtual void testGroupStarting( GroupInfo const& _groupInfo ) CATCH_OVERRIDE {
+            currentGroupInfo = _groupInfo;
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) CATCH_OVERRIDE {
+            currentTestCaseInfo = _testInfo;
+        }
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
+            m_sectionStack.push_back( _sectionInfo );
+        }
+
+        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) CATCH_OVERRIDE {
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) CATCH_OVERRIDE {
+            currentTestCaseInfo.reset();
+        }
+        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) CATCH_OVERRIDE {
+            currentGroupInfo.reset();
+        }
+        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) CATCH_OVERRIDE {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        Ptr<IConfig const> m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
+        template<typename T, typename ChildNodeT>
+        struct Node : SharedImpl<> {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            typedef std::vector<Ptr<ChildNodeT> > ChildNodes;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode : SharedImpl<> {
+            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
+            virtual ~SectionNode();
+
+            bool operator == ( SectionNode const& other ) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == ( Ptr<SectionNode> const& other ) const {
+                return operator==( *other );
+            }
+
+            SectionStats stats;
+            typedef std::vector<Ptr<SectionNode> > ChildSections;
+            typedef std::vector<AssertionStats> Assertions;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() ( Ptr<SectionNode> const& node ) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+        private:
+            void operator=( BySectionInfo const& );
+            SectionInfo const& m_other;
+        };
+
+        typedef Node<TestCaseStats, SectionNode> TestCaseNode;
+        typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
+        typedef Node<TestRunStats, TestGroupNode> TestRunNode;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+        }
+        ~CumulativeReporterBase();
+
+        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
+            return m_reporterPrefs;
+        }
+
+        virtual void testRunStarting( TestRunInfo const& ) CATCH_OVERRIDE {}
+        virtual void testGroupStarting( GroupInfo const& ) CATCH_OVERRIDE {}
+
+        virtual void testCaseStarting( TestCaseInfo const& ) CATCH_OVERRIDE {}
+
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            Ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = new SectionNode( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                SectionNode::ChildSections::const_iterator it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = new SectionNode( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = node;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+            assert( !m_sectionStack.empty() );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back( assertionStats );
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression( sectionNode.assertions.back().assertionResult );
+            return true;
+        }
+        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
+            assert( !m_sectionStack.empty() );
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
+            assert( m_sectionStack.size() == 0 );
+            node->children.push_back( m_rootSection );
+            m_testCases.push_back( node );
+            m_rootSection.reset();
+
+            assert( m_deepestSection );
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+            Ptr<TestGroupNode> node = new TestGroupNode( testGroupStats );
+            node->children.swap( m_testCases );
+            m_testGroups.push_back( node );
+        }
+        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
+            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
+            node->children.swap( m_testGroups );
+            m_testRuns.push_back( node );
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {}
+
+        virtual void prepareExpandedExpression( AssertionResult& result ) const {
+            if( result.isOk() )
+                result.discardDecomposedExpression();
+            else
+                result.expandDecomposedExpression();
+        }
+
+        Ptr<IConfig const> m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<Ptr<SectionNode> > > m_sections;
+        std::vector<Ptr<TestCaseNode> > m_testCases;
+        std::vector<Ptr<TestGroupNode> > m_testGroups;
+
+        std::vector<Ptr<TestRunNode> > m_testRuns;
+
+        Ptr<SectionNode> m_rootSection;
+        Ptr<SectionNode> m_deepestSection;
+        std::vector<Ptr<SectionNode> > m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase {
+        TestEventListenerBase( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config )
+        {}
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
+        virtual bool assertionEnded( AssertionStats const& ) CATCH_OVERRIDE {
+            return false;
+        }
+    };
+
+} // end namespace Catch
+
+// #included from: ../internal/catch_reporter_registrars.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+namespace Catch {
+
+    template<typename T>
+    class LegacyReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new LegacyReporterAdapter( new T( config ) );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        LegacyReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public SharedImpl<IReporterFactory> {
+
+            // *** Please Note ***:
+            // - If you end up here looking at a compiler error because it's trying to register
+            // your custom reporter class be aware that the native reporter interface has changed
+            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
+            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
+            // However please consider updating to the new interface as the old one is now
+            // deprecated and will probably be removed quite soon!
+            // Please contact me via github if you have any questions at all about this.
+            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
+            // no idea who is actually using custom reporters at all (possibly no-one!).
+            // The new interface is designed to minimise exposure to interface changes in the future.
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new T( config );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class ListenerFactory : public SharedImpl<IReporterFactory> {
+
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new T( config );
+            }
+            virtual std::string getDescription() const {
+                return std::string();
+            }
+        };
+
+    public:
+
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( new ListenerFactory() );
+        }
+    };
+}
+
+#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
+    namespace{ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+
+#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+
+// Deprecated - use the form without INTERNAL_
+#define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+
+// #included from: ../internal/catch_xmlwriter.hpp
+#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
+
+#include <sstream>
+#include <string>
+#include <vector>
+#include <iomanip>
+
+namespace Catch {
+
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes )
+        :   m_str( str ),
+            m_forWhat( forWhat )
+        {}
+
+        void encodeTo( std::ostream& os ) const {
+
+            // Apostrophe escaping not necessary if we always use " to write attributes
+            // (see: http://www.w3.org/TR/xml/#syntax)
+
+            for( std::size_t i = 0; i < m_str.size(); ++ i ) {
+                char c = m_str[i];
+                switch( c ) {
+                    case '<':   os << "&lt;"; break;
+                    case '&':   os << "&amp;"; break;
+
+                    case '>':
+                        // See: http://www.w3.org/TR/xml/#syntax
+                        if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' )
+                            os << "&gt;";
+                        else
+                            os << c;
+                        break;
+
+                    case '\"':
+                        if( m_forWhat == ForAttributes )
+                            os << "&quot;";
+                        else
+                            os << c;
+                        break;
+
+                    default:
+                        // Escape control chars - based on contribution by @espenalb in PR #465 and
+                        // by @mrpi PR #588
+                        if ( ( c >= 0 && c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) {
+                            // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                            os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+                               << static_cast<int>( c );
+                        }
+                        else
+                            os << c;
+                }
+            }
+        }
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+            xmlEncode.encodeTo( os );
+            return os;
+        }
+
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer )
+            :   m_writer( writer )
+            {}
+
+            ScopedElement( ScopedElement const& other )
+            :   m_writer( other.m_writer ){
+                other.m_writer = CATCH_NULL;
+            }
+
+            ~ScopedElement() {
+                if( m_writer )
+                    m_writer->endElement();
+            }
+
+            ScopedElement& writeText( std::string const& text, bool indent = true ) {
+                m_writer->writeText( text, indent );
+                return *this;
+            }
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer;
+        };
+
+        XmlWriter()
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( Catch::cout() )
+        {
+            writeDeclaration();
+        }
+
+        XmlWriter( std::ostream& os )
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( os )
+        {
+            writeDeclaration();
+        }
+
+        ~XmlWriter() {
+            while( !m_tags.empty() )
+                endElement();
+        }
+
+        XmlWriter& startElement( std::string const& name ) {
+            ensureTagClosed();
+            newlineIfNecessary();
+            m_os << m_indent << '<' << name;
+            m_tags.push_back( name );
+            m_indent += "  ";
+            m_tagIsOpen = true;
+            return *this;
+        }
+
+        ScopedElement scopedElement( std::string const& name ) {
+            ScopedElement scoped( this );
+            startElement( name );
+            return scoped;
+        }
+
+        XmlWriter& endElement() {
+            newlineIfNecessary();
+            m_indent = m_indent.substr( 0, m_indent.size()-2 );
+            if( m_tagIsOpen ) {
+                m_os << "/>";
+                m_tagIsOpen = false;
+            }
+            else {
+                m_os << m_indent << "</" << m_tags.back() << ">";
+            }
+            m_os << std::endl;
+            m_tags.pop_back();
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
+            if( !name.empty() && !attribute.empty() )
+                m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
+            m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+            return *this;
+        }
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            std::ostringstream oss;
+            oss << attribute;
+            return writeAttribute( name, oss.str() );
+        }
+
+        XmlWriter& writeText( std::string const& text, bool indent = true ) {
+            if( !text.empty() ){
+                bool tagWasOpen = m_tagIsOpen;
+                ensureTagClosed();
+                if( tagWasOpen && indent )
+                    m_os << m_indent;
+                m_os << XmlEncode( text );
+                m_needsNewline = true;
+            }
+            return *this;
+        }
+
+        XmlWriter& writeComment( std::string const& text ) {
+            ensureTagClosed();
+            m_os << m_indent << "<!--" << text << "-->";
+            m_needsNewline = true;
+            return *this;
+        }
+
+        void writeStylesheetRef( std::string const& url ) {
+            m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+        }
+
+        XmlWriter& writeBlankLine() {
+            ensureTagClosed();
+            m_os << '\n';
+            return *this;
+        }
+
+        void ensureTagClosed() {
+            if( m_tagIsOpen ) {
+                m_os << ">" << std::endl;
+                m_tagIsOpen = false;
+            }
+        }
+
+    private:
+        XmlWriter( XmlWriter const& );
+        void operator=( XmlWriter const& );
+
+        void writeDeclaration() {
+            m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+        }
+
+        void newlineIfNecessary() {
+            if( m_needsNewline ) {
+                m_os << std::endl;
+                m_needsNewline = false;
+            }
+        }
+
+        bool m_tagIsOpen;
+        bool m_needsNewline;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase {
+    public:
+        XmlReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_xml(_config.stream()),
+            m_sectionDepth( 0 )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        virtual ~XmlReporter() CATCH_OVERRIDE;
+
+        static std::string getDescription() {
+            return "Reports test results as an XML document";
+        }
+
+        virtual std::string getStylesheetRef() const {
+            return std::string();
+        }
+
+        void writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+            m_xml
+                .writeAttribute( "filename", sourceInfo.file )
+                .writeAttribute( "line", sourceInfo.line );
+        }
+
+    public: // StreamingReporterBase
+
+        virtual void noMatchingTestCases( std::string const& s ) CATCH_OVERRIDE {
+            StreamingReporterBase::noMatchingTestCases( s );
+        }
+
+        virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::testRunStarting( testInfo );
+            std::string stylesheetRef = getStylesheetRef();
+            if( !stylesheetRef.empty() )
+                m_xml.writeStylesheetRef( stylesheetRef );
+            m_xml.startElement( "Catch" );
+            if( !m_config->name().empty() )
+                m_xml.writeAttribute( "name", m_config->name() );
+        }
+
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            m_xml.startElement( "Group" )
+                .writeAttribute( "name", groupInfo.name );
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::testCaseStarting(testInfo);
+            m_xml.startElement( "TestCase" )
+                .writeAttribute( "name", trim( testInfo.name ) )
+                .writeAttribute( "description", testInfo.description )
+                .writeAttribute( "tags", testInfo.tagsAsString );
+
+            writeSourceInfo( testInfo.lineInfo );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                m_testCaseTimer.start();
+            m_xml.ensureTagClosed();
+        }
+
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::sectionStarting( sectionInfo );
+            if( m_sectionDepth++ > 0 ) {
+                m_xml.startElement( "Section" )
+                    .writeAttribute( "name", trim( sectionInfo.name ) )
+                    .writeAttribute( "description", sectionInfo.description );
+                writeSourceInfo( sectionInfo.lineInfo );
+                m_xml.ensureTagClosed();
+            }
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { }
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+
+            AssertionResult const& result = assertionStats.assertionResult;
+
+            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+            if( includeResults || result.getResultType() == ResultWas::Warning ) {
+                // Print any info messages in <Info> tags.
+                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                     it != itEnd;
+                     ++it ) {
+                    if( it->type == ResultWas::Info && includeResults ) {
+                        m_xml.scopedElement( "Info" )
+                                .writeText( it->message );
+                    } else if ( it->type == ResultWas::Warning ) {
+                        m_xml.scopedElement( "Warning" )
+                                .writeText( it->message );
+                    }
+                }
+            }
+
+            // Drop out if result was successful but we're not printing them.
+            if( !includeResults && result.getResultType() != ResultWas::Warning )
+                return true;
+
+            // Print the expression if there is one.
+            if( result.hasExpression() ) {
+                m_xml.startElement( "Expression" )
+                    .writeAttribute( "success", result.succeeded() )
+                    .writeAttribute( "type", result.getTestMacroName() );
+
+                writeSourceInfo( result.getSourceInfo() );
+
+                m_xml.scopedElement( "Original" )
+                    .writeText( result.getExpression() );
+                m_xml.scopedElement( "Expanded" )
+                    .writeText( result.getExpandedExpression() );
+            }
+
+            // And... Print a result applicable to each result type.
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                    m_xml.startElement( "Exception" );
+                    writeSourceInfo( result.getSourceInfo() );
+                    m_xml.writeText( result.getMessage() );
+                    m_xml.endElement();
+                    break;
+                case ResultWas::FatalErrorCondition:
+                    m_xml.startElement( "FatalErrorCondition" );
+                    writeSourceInfo( result.getSourceInfo() );
+                    m_xml.writeText( result.getMessage() );
+                    m_xml.endElement();
+                    break;
+                case ResultWas::Info:
+                    m_xml.scopedElement( "Info" )
+                        .writeText( result.getMessage() );
+                    break;
+                case ResultWas::Warning:
+                    // Warning will already have been written
+                    break;
+                case ResultWas::ExplicitFailure:
+                    m_xml.startElement( "Failure" );
+                    writeSourceInfo( result.getSourceInfo() );
+                    m_xml.writeText( result.getMessage() );
+                    m_xml.endElement();
+                    break;
+                default:
+                    break;
+            }
+
+            if( result.hasExpression() )
+                m_xml.endElement();
+
+            return true;
+        }
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::sectionEnded( sectionStats );
+            if( --m_sectionDepth > 0 ) {
+                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+                e.writeAttribute( "successes", sectionStats.assertions.passed );
+                e.writeAttribute( "failures", sectionStats.assertions.failed );
+                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+                if ( m_config->showDurations() == ShowDurations::Always )
+                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+                m_xml.endElement();
+            }
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+            if( !testCaseStats.stdOut.empty() )
+                m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
+            if( !testCaseStats.stdErr.empty() )
+                m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
+
+            m_xml.endElement();
+        }
+
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            // TODO: Check testGroupStats.aborting and act accordingly.
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testRunEnded( testRunStats );
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth;
+    };
+
+     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_junit.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+#include <assert.h>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            // Beware, this is not reentrant because of backward compatibility issues
+            // Also, UTC only, again because of backward compatibility (%z is C++11)
+            time_t rawtime;
+            std::time(&rawtime);
+            const size_t timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            std::tm* timeInfo;
+            timeInfo = std::gmtime(&rawtime);
+#endif
+
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+
+    }
+
+    class JunitReporter : public CumulativeReporterBase {
+    public:
+        JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() ),
+            unexpectedExceptions( 0 ),
+            m_okToFail( false )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        virtual ~JunitReporter() CATCH_OVERRIDE;
+
+        static std::string getDescription() {
+            return "Reports test results in an XML format that looks like Ant's junitreport target";
+        }
+
+        virtual void noMatchingTestCases( std::string const& /*spec*/ ) CATCH_OVERRIDE {}
+
+        virtual void testRunStarting( TestRunInfo const& runInfo ) CATCH_OVERRIDE {
+            CumulativeReporterBase::testRunStarting( runInfo );
+            xml.startElement( "testsuites" );
+        }
+
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
+            suiteTimer.start();
+            stdOutForSuite.str("");
+            stdErrForSuite.str("");
+            unexpectedExceptions = 0;
+            CumulativeReporterBase::testGroupStarting( groupInfo );
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& testCaseInfo ) CATCH_OVERRIDE {
+            m_okToFail = testCaseInfo.okToFail();
+        }
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+                unexpectedExceptions++;
+            return CumulativeReporterBase::assertionEnded( assertionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+            stdOutForSuite << testCaseStats.stdOut;
+            stdErrForSuite << testCaseStats.stdErr;
+            CumulativeReporterBase::testCaseEnded( testCaseStats );
+        }
+
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+            double suiteTime = suiteTimer.getElapsedSeconds();
+            CumulativeReporterBase::testGroupEnded( testGroupStats );
+            writeGroup( *m_testGroups.back(), suiteTime );
+        }
+
+        virtual void testRunEndedCumulative() CATCH_OVERRIDE {
+            xml.endElement();
+        }
+
+        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+            TestGroupStats const& stats = groupNode.value;
+            xml.writeAttribute( "name", stats.groupInfo.name );
+            xml.writeAttribute( "errors", unexpectedExceptions );
+            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+            xml.writeAttribute( "tests", stats.totals.assertions.total() );
+            xml.writeAttribute( "hostname", "tbd" ); // !TBD
+            if( m_config->showDurations() == ShowDurations::Never )
+                xml.writeAttribute( "time", "" );
+            else
+                xml.writeAttribute( "time", suiteTime );
+            xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+            // Write test cases
+            for( TestGroupNode::ChildNodes::const_iterator
+                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
+                    it != itEnd;
+                    ++it )
+                writeTestCase( **it );
+
+            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
+            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
+        }
+
+        void writeTestCase( TestCaseNode const& testCaseNode ) {
+            TestCaseStats const& stats = testCaseNode.value;
+
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert( testCaseNode.children.size() == 1 );
+            SectionNode const& rootSection = *testCaseNode.children.front();
+
+            std::string className = stats.testInfo.className;
+
+            if( className.empty() ) {
+                if( rootSection.childSections.empty() )
+                    className = "global";
+            }
+            writeSection( className, "", rootSection );
+        }
+
+        void writeSection(  std::string const& className,
+                            std::string const& rootName,
+                            SectionNode const& sectionNode ) {
+            std::string name = trim( sectionNode.stats.sectionInfo.name );
+            if( !rootName.empty() )
+                name = rootName + '/' + name;
+
+            if( !sectionNode.assertions.empty() ||
+                !sectionNode.stdOut.empty() ||
+                !sectionNode.stdErr.empty() ) {
+                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+                if( className.empty() ) {
+                    xml.writeAttribute( "classname", name );
+                    xml.writeAttribute( "name", "root" );
+                }
+                else {
+                    xml.writeAttribute( "classname", className );
+                    xml.writeAttribute( "name", name );
+                }
+                xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );
+
+                writeAssertions( sectionNode );
+
+                if( !sectionNode.stdOut.empty() )
+                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
+                if( !sectionNode.stdErr.empty() )
+                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
+            }
+            for( SectionNode::ChildSections::const_iterator
+                    it = sectionNode.childSections.begin(),
+                    itEnd = sectionNode.childSections.end();
+                    it != itEnd;
+                    ++it )
+                if( className.empty() )
+                    writeSection( name, "", **it );
+                else
+                    writeSection( className, name, **it );
+        }
+
+        void writeAssertions( SectionNode const& sectionNode ) {
+            for( SectionNode::Assertions::const_iterator
+                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
+                    it != itEnd;
+                    ++it )
+                writeAssertion( *it );
+        }
+        void writeAssertion( AssertionStats const& stats ) {
+            AssertionResult const& result = stats.assertionResult;
+            if( !result.isOk() ) {
+                std::string elementName;
+                switch( result.getResultType() ) {
+                    case ResultWas::ThrewException:
+                    case ResultWas::FatalErrorCondition:
+                        elementName = "error";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        elementName = "failure";
+                        break;
+
+                    // We should never see these here:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                    case ResultWas::Ok:
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        elementName = "internalError";
+                        break;
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+                xml.writeAttribute( "message", result.getExpandedExpression() );
+                xml.writeAttribute( "type", result.getTestMacroName() );
+
+                std::ostringstream oss;
+                if( !result.getMessage().empty() )
+                    oss << result.getMessage() << '\n';
+                for( std::vector<MessageInfo>::const_iterator
+                        it = stats.infoMessages.begin(),
+                        itEnd = stats.infoMessages.end();
+                            it != itEnd;
+                            ++it )
+                    if( it->type == ResultWas::Info )
+                        oss << it->message << '\n';
+
+                oss << "at " << result.getSourceInfo();
+                xml.writeText( oss.str(), false );
+            }
+        }
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::ostringstream stdOutForSuite;
+        std::ostringstream stdErrForSuite;
+        unsigned int unexpectedExceptions;
+        bool m_okToFail;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_console.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+#include <cfloat>
+#include <cstdio>
+
+namespace Catch {
+
+    struct ConsoleReporter : StreamingReporterBase {
+        ConsoleReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_headerPrinted( false )
+        {}
+
+        virtual ~ConsoleReporter() CATCH_OVERRIDE;
+        static std::string getDescription() {
+            return "Reports test results as plain lines of text";
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+            // Drop out if result was successful but we're not printing them.
+            if( !includeResults && result.getResultType() != ResultWas::Warning )
+                return false;
+
+            lazyPrint();
+
+            AssertionPrinter printer( stream, _assertionStats, includeResults );
+            printer.print();
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionStarting( _sectionInfo );
+        }
+        virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE {
+            if( _sectionStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                if( m_sectionStack.size() > 1 )
+                    stream << "\nNo assertions in section";
+                else
+                    stream << "\nNo assertions in test case";
+                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+            }
+            if( m_config->showDurations() == ShowDurations::Always ) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+            if( m_headerPrinted ) {
+                m_headerPrinted = false;
+            }
+            StreamingReporterBase::sectionEnded( _sectionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+            m_headerPrinted = false;
+        }
+        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
+            if( currentGroupInfo.used ) {
+                printSummaryDivider();
+                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+                printTotals( _testGroupStats.totals );
+                stream << '\n' << std::endl;
+            }
+            StreamingReporterBase::testGroupEnded( _testGroupStats );
+        }
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
+            printTotalsDivider( _testRunStats.totals );
+            printTotals( _testRunStats.totals );
+            stream << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            :   stream( _stream ),
+                stats( _stats ),
+                result( _stats.assertionResult ),
+                colour( Colour::None ),
+                message( result.getMessage() ),
+                messages( _stats.infoMessages ),
+                printInfoMessages( _printInfoMessages )
+            {
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        colour = Colour::Success;
+                        passOrFail = "PASSED";
+                        //if( result.hasMessage() )
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() ) {
+                            colour = Colour::Success;
+                            passOrFail = "FAILED - but was ok";
+                        }
+                        else {
+                            colour = Colour::Error;
+                            passOrFail = "FAILED";
+                        }
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ThrewException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to unexpected exception with ";
+                        if (_stats.infoMessages.size() == 1)
+                            messageLabel += "message";
+                        if (_stats.infoMessages.size() > 1)
+                            messageLabel += "messages";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to a fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "because no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::Info:
+                        messageLabel = "info";
+                        break;
+                    case ResultWas::Warning:
+                        messageLabel = "warning";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        passOrFail = "FAILED";
+                        colour = Colour::Error;
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "explicitly with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "explicitly with messages";
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        passOrFail = "** internal error **";
+                        colour = Colour::Error;
+                        break;
+                }
+            }
+
+            void print() const {
+                printSourceInfo();
+                if( stats.totals.assertions.total() > 0 ) {
+                    if( result.isOk() )
+                        stream << '\n';
+                    printResultType();
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                }
+                else {
+                    stream << '\n';
+                }
+                printMessage();
+            }
+
+        private:
+            void printResultType() const {
+                if( !passOrFail.empty() ) {
+                    Colour colourGuard( colour );
+                    stream << passOrFail << ":\n";
+                }
+            }
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    Colour colourGuard( Colour::OriginalExpression );
+                    stream  << "  ";
+                    stream << result.getExpressionInMacro();
+                    stream << '\n';
+                }
+            }
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    stream << "with expansion:\n";
+                    Colour colourGuard( Colour::ReconstructedExpression );
+                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << '\n';
+                }
+            }
+            void printMessage() const {
+                if( !messageLabel.empty() )
+                    stream << messageLabel << ':' << '\n';
+                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+                        it != itEnd;
+                        ++it ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || it->type != ResultWas::Info )
+                        stream << Text( it->message, TextAttributes().setIndent(2) ) << '\n';
+                }
+            }
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ": ";
+            }
+
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            Colour::Code colour;
+            std::string passOrFail;
+            std::string messageLabel;
+            std::string message;
+            std::vector<MessageInfo> messages;
+            bool printInfoMessages;
+        };
+
+        void lazyPrint() {
+
+            if( !currentTestRunInfo.used )
+                lazyPrintRunInfo();
+            if( !currentGroupInfo.used )
+                lazyPrintGroupInfo();
+
+            if( !m_headerPrinted ) {
+                printTestCaseAndSectionHeader();
+                m_headerPrinted = true;
+            }
+        }
+        void lazyPrintRunInfo() {
+            stream  << '\n' << getLineOfChars<'~'>() << '\n';
+            Colour colour( Colour::SecondaryText );
+            stream  << currentTestRunInfo->name
+                    << " is a Catch v"  << libraryVersion() << " host application.\n"
+                    << "Run with -? for options\n\n";
+
+            if( m_config->rngSeed() != 0 )
+                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+            currentTestRunInfo.used = true;
+        }
+        void lazyPrintGroupInfo() {
+            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
+                printClosedHeader( "Group: " + currentGroupInfo->name );
+                currentGroupInfo.used = true;
+            }
+        }
+        void printTestCaseAndSectionHeader() {
+            assert( !m_sectionStack.empty() );
+            printOpenHeader( currentTestCaseInfo->name );
+
+            if( m_sectionStack.size() > 1 ) {
+                Colour colourGuard( Colour::Headers );
+
+                std::vector<SectionInfo>::const_iterator
+                    it = m_sectionStack.begin()+1, // Skip first section (test case)
+                    itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( it->name, 2 );
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+            if( !lineInfo.empty() ){
+                stream << getLineOfChars<'-'>() << '\n';
+                Colour colourGuard( Colour::FileName );
+                stream << lineInfo << '\n';
+            }
+            stream << getLineOfChars<'.'>() << '\n' << std::endl;
+        }
+
+        void printClosedHeader( std::string const& _name ) {
+            printOpenHeader( _name );
+            stream << getLineOfChars<'.'>() << '\n';
+        }
+        void printOpenHeader( std::string const& _name ) {
+            stream  << getLineOfChars<'-'>() << '\n';
+            {
+                Colour colourGuard( Colour::Headers );
+                printHeaderString( _name );
+            }
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            stream << Text( _string, TextAttributes()
+                                        .setIndent( indent+i)
+                                        .setInitialIndent( indent ) ) << '\n';
+        }
+
+        struct SummaryColumn {
+
+            SummaryColumn( std::string const& _label, Colour::Code _colour )
+            :   label( _label ),
+                colour( _colour )
+            {}
+            SummaryColumn addRow( std::size_t count ) {
+                std::ostringstream oss;
+                oss << count;
+                std::string row = oss.str();
+                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
+                    while( it->size() < row.size() )
+                        *it = ' ' + *it;
+                    while( it->size() > row.size() )
+                        row = ' ' + row;
+                }
+                rows.push_back( row );
+                return *this;
+            }
+
+            std::string label;
+            Colour::Code colour;
+            std::vector<std::string> rows;
+
+        };
+
+        void printTotals( Totals const& totals ) {
+            if( totals.testCases.total() == 0 ) {
+                stream << Colour( Colour::Warning ) << "No tests ran\n";
+            }
+            else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
+                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
+                stream << " ("
+                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
+                        << pluralise( totals.testCases.passed, "test case" ) << ')'
+                        << '\n';
+            }
+            else {
+
+                std::vector<SummaryColumn> columns;
+                columns.push_back( SummaryColumn( "", Colour::None )
+                                        .addRow( totals.testCases.total() )
+                                        .addRow( totals.assertions.total() ) );
+                columns.push_back( SummaryColumn( "passed", Colour::Success )
+                                        .addRow( totals.testCases.passed )
+                                        .addRow( totals.assertions.passed ) );
+                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+                                        .addRow( totals.testCases.failed )
+                                        .addRow( totals.assertions.failed ) );
+                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+                                        .addRow( totals.testCases.failedButOk )
+                                        .addRow( totals.assertions.failedButOk ) );
+
+                printSummaryRow( "test cases", columns, 0 );
+                printSummaryRow( "assertions", columns, 1 );
+            }
+        }
+        void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
+            for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
+                std::string value = it->rows[row];
+                if( it->label.empty() ) {
+                    stream << label << ": ";
+                    if( value != "0" )
+                        stream << value;
+                    else
+                        stream << Colour( Colour::Warning ) << "- none -";
+                }
+                else if( value != "0" ) {
+                    stream  << Colour( Colour::LightGrey ) << " | ";
+                    stream  << Colour( it->colour )
+                            << value << ' ' << it->label;
+                }
+            }
+            stream << '\n';
+        }
+
+        static std::size_t makeRatio( std::size_t number, std::size_t total ) {
+            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
+            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
+        }
+        static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
+            if( i > j && i > k )
+                return i;
+            else if( j > k )
+                return j;
+            else
+                return k;
+        }
+
+        void printTotalsDivider( Totals const& totals ) {
+            if( totals.testCases.total() > 0 ) {
+                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
+                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
+                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
+                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
+                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )--;
+
+                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
+                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
+                if( totals.testCases.allPassed() )
+                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
+                else
+                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
+            }
+            else {
+                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
+            }
+            stream << '\n';
+        }
+        void printSummaryDivider() {
+            stream << getLineOfChars<'-'>() << '\n';
+        }
+
+    private:
+        bool m_headerPrinted;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_compact.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase {
+
+        CompactReporter( ReporterConfig const& _config )
+        : StreamingReporterBase( _config )
+        {}
+
+        virtual ~CompactReporter();
+
+        static std::string getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {}
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void sectionEnded(SectionStats const& _sectionStats) CATCH_OVERRIDE {
+            if (m_config->showDurations() == ShowDurations::Always) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+        }
+
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( _testRunStats.totals );
+            stream << '\n' << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            : stream( _stream )
+            , stats( _stats )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( _printInfoMessages )
+            {}
+
+            void print() {
+                printSourceInfo();
+
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( Colour::ResultSuccess, passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() )
+                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
+                        else
+                            printResultType( Colour::Error, failedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( Colour::None, "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( Colour::None, "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( Colour::Error, "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            // Colour::LightGrey
+
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+#ifdef CATCH_PLATFORM_MAC
+            static const char* failedString() { return "FAILED"; }
+            static const char* passedString() { return "PASSED"; }
+#else
+            static const char* failedString() { return "failed"; }
+            static const char* passedString() { return "passed"; }
+#endif
+
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ':';
+            }
+
+            void printResultType( Colour::Code colour, std::string const& passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    {
+                        Colour colourGuard( colour );
+                        stream << ' ' << passOrFail;
+                    }
+                    stream << ':';
+                }
+            }
+
+            void printIssue( std::string const& issue ) const {
+                stream << ' ' << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ';';
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << ' ' << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    stream << result.getExpandedExpression();
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << '\'';
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if ( itMessage == messages.end() )
+                    return;
+
+                // using messages.end() directly yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ':';
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << '\'';
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+        };
+
+        // Colour, message variants:
+        // - white: No tests ran.
+        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+        // - white: Passed [both/all] N test cases (no assertions).
+        // -   red: Failed N tests cases, failed M assertions.
+        // - green: Passed [both/all] N tests cases with M assertions.
+
+        std::string bothOrAll( std::size_t count ) const {
+            return count == 1 ? std::string() : count == 2 ? "both " : "all " ;
+        }
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "No tests ran.";
+            }
+            else if( totals.testCases.failed == totals.testCases.total() ) {
+                Colour colour( Colour::ResultError );
+                const std::string qualify_assertions_failed =
+                    totals.assertions.failed == totals.assertions.total() ?
+                        bothOrAll( totals.assertions.failed ) : std::string();
+                stream <<
+                    "Failed " << bothOrAll( totals.testCases.failed )
+                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << qualify_assertions_failed <<
+                                 pluralise( totals.assertions.failed, "assertion" ) << '.';
+            }
+            else if( totals.assertions.total() == 0 ) {
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.total() )
+                              << pluralise( totals.testCases.total(), "test case" )
+                              << " (no assertions).";
+            }
+            else if( totals.assertions.failed ) {
+                Colour colour( Colour::ResultError );
+                stream <<
+                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << '.';
+            }
+            else {
+                Colour colour( Colour::ResultSuccess );
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.passed )
+                              << pluralise( totals.testCases.passed, "test case"  ) <<
+                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << '.';
+            }
+        }
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+
+namespace Catch {
+    // These are all here to avoid warnings about not having any out of line
+    // virtual methods
+    NonCopyable::~NonCopyable() {}
+    IShared::~IShared() {}
+    IStream::~IStream() CATCH_NOEXCEPT {}
+    FileStream::~FileStream() CATCH_NOEXCEPT {}
+    CoutStream::~CoutStream() CATCH_NOEXCEPT {}
+    DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {}
+    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
+    IContext::~IContext() {}
+    IResultCapture::~IResultCapture() {}
+    ITestCase::~ITestCase() {}
+    ITestCaseRegistry::~ITestCaseRegistry() {}
+    IRegistryHub::~IRegistryHub() {}
+    IMutableRegistryHub::~IMutableRegistryHub() {}
+    IExceptionTranslator::~IExceptionTranslator() {}
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
+    IReporter::~IReporter() {}
+    IReporterFactory::~IReporterFactory() {}
+    IReporterRegistry::~IReporterRegistry() {}
+    IStreamingReporter::~IStreamingReporter() {}
+    AssertionStats::~AssertionStats() {}
+    SectionStats::~SectionStats() {}
+    TestCaseStats::~TestCaseStats() {}
+    TestGroupStats::~TestGroupStats() {}
+    TestRunStats::~TestRunStats() {}
+    CumulativeReporterBase::SectionNode::~SectionNode() {}
+    CumulativeReporterBase::~CumulativeReporterBase() {}
+
+    StreamingReporterBase::~StreamingReporterBase() {}
+    ConsoleReporter::~ConsoleReporter() {}
+    CompactReporter::~CompactReporter() {}
+    IRunner::~IRunner() {}
+    IMutableContext::~IMutableContext() {}
+    IConfig::~IConfig() {}
+    XmlReporter::~XmlReporter() {}
+    JunitReporter::~JunitReporter() {}
+    TestRegistry::~TestRegistry() {}
+    FreeFunctionTestCase::~FreeFunctionTestCase() {}
+    IGeneratorInfo::~IGeneratorInfo() {}
+    IGeneratorsForTest::~IGeneratorsForTest() {}
+    WildcardPattern::~WildcardPattern() {}
+    TestSpec::Pattern::~Pattern() {}
+    TestSpec::NamePattern::~NamePattern() {}
+    TestSpec::TagPattern::~TagPattern() {}
+    TestSpec::ExcludedPattern::~ExcludedPattern() {}
+    Matchers::Impl::MatcherUntypedBase::~MatcherUntypedBase() {}
+
+    void Config::dummy() {}
+
+    namespace TestCaseTracking {
+        ITracker::~ITracker() {}
+        TrackerBase::~TrackerBase() {}
+        SectionTracker::~SectionTracker() {}
+        IndexTracker::~IndexTracker() {}
+    }
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// #included from: internal/catch_default_main.hpp
+#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
+
+#ifndef __OBJC__
+
+#if defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    int result = Catch::Session().run( argc, argv );
+    return ( result < 0xff ? result : 0xff );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char* const*)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return ( result < 0xff ? result : 0xff );
+}
+
+#endif // __OBJC__
+
+#endif
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+//////
+
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#else
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr  )
+#endif
+
+#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
+
+#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
+
+#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
+
+#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
+#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+    #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#else
+    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description )
+    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
+#endif
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
+#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define CATCH_GIVEN( desc )    CATCH_SECTION( std::string( "Given: ") + desc, "" )
+#define CATCH_WHEN( desc )     CATCH_SECTION( std::string( " When: ") + desc, "" )
+#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
+#define CATCH_THEN( desc )     CATCH_SECTION( std::string( " Then: ") + desc, "" )
+#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+
+#else
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, expr  )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#endif
+
+#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
+
+#define CHECK( expr ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
+
+#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
+
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
+#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#else
+#define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description )
+    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define FAIL( msg ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
+#endif
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
+#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define GIVEN( desc )    SECTION( std::string("   Given: ") + desc, "" )
+#define WHEN( desc )     SECTION( std::string("    When: ") + desc, "" )
+#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" )
+#define THEN( desc )     SECTION( std::string("    Then: ") + desc, "" )
+#define AND_THEN( desc ) SECTION( std::string("     And: ") + desc, "" )
+
+using Catch::Detail::Approx;
+
+// #included from: internal/catch_reenable_warnings.h
+
+#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/third_party/libosmium/test/data-tests/CMakeLists.txt b/third_party/libosmium/test/data-tests/CMakeLists.txt
index eed19f32fbe..135cc4a73b7 100644
--- a/third_party/libosmium/test/data-tests/CMakeLists.txt
+++ b/third_party/libosmium/test/data-tests/CMakeLists.txt
@@ -15,7 +15,7 @@ if(NOT GDAL_FOUND OR NOT EXPAT_FOUND)
 endif()
 
 message(STATUS "Looking for osm-testdata")
-find_path(OSM_TESTDATA grid/data/all.osm HINT ../../../osm-testdata)
+find_path(OSM_TESTDATA grid/data/all.osm HINT osm-testdata)
 if(OSM_TESTDATA STREQUAL "OSM_TESTDATA-NOTFOUND")
     message(STATUS "Looking for osm-testdata - not found (data tests disabled)")
     message(STATUS "Configuring data tests - failed")
@@ -26,8 +26,9 @@ message(STATUS "Looking for osm-testdata - found")
 
 #-----------------------------------------------------------------------------
 
-include_directories("include")
-include_directories("../include")
+include_directories(SYSTEM ../catch)
+include_directories(include)
+include_directories(../include)
 
 
 #-----------------------------------------------------------------------------
@@ -102,15 +103,16 @@ if(RUBY AND GEM_json_FOUND AND SPATIALITE)
     add_executable(testdata-multipolygon testdata-multipolygon.cpp)
     set_pthread_on_target(testdata-multipolygon)
     target_link_libraries(testdata-multipolygon
-                        ${OSMIUM_XML_LIBRARIES}
-                        ${GDAL_LIBRARIES}
+                          ${OSMIUM_XML_LIBRARIES}
+                          ${GDAL_LIBRARIES}
     )
 
     add_test(NAME testdata-multipolygon
-            COMMAND ${CMAKE_COMMAND}
-                -D OSM_TESTDATA=${OSM_TESTDATA}
-                -D RUBY=${RUBY}
-                -P ${CMAKE_CURRENT_SOURCE_DIR}/run-testdata-multipolygon.cmake)
+             COMMAND ${CMAKE_COMMAND}
+                 -D OSM_TESTDATA=${OSM_TESTDATA}
+                 -D RUBY=${RUBY}
+                 -D EXECUTABLE=$<TARGET_FILE:testdata-multipolygon>
+                 -P ${CMAKE_CURRENT_SOURCE_DIR}/run-testdata-multipolygon.cmake)
 
     set_tests_properties(testdata-multipolygon PROPERTIES LABELS "data;slow")
     configure_file(multipolygon.qgs ${CMAKE_CURRENT_BINARY_DIR}/multipolygon.qgs @ONLY)
diff --git a/third_party/libosmium/test/data-tests/include/check_basics_handler.hpp b/third_party/libosmium/test/data-tests/include/check_basics_handler.hpp
index 757ab4d3f81..f70c52583b8 100644
--- a/third_party/libosmium/test/data-tests/include/check_basics_handler.hpp
+++ b/third_party/libosmium/test/data-tests/include/check_basics_handler.hpp
@@ -34,13 +34,13 @@ class CheckBasicsHandler : public osmium::handler::Handler {
     void id_check(osmium::object_id_type id, osmium::object_id_type min, osmium::object_id_type max) {
         if (id < m_id_range + min || id > m_id_range + max) {
             std::cerr << "  id " << id << " out of range for this test case\n";
-            exit(1);
+            std::exit(1);
         }
 
         auto r = m_ids.insert(id);
         if (!r.second) {
             std::cerr << "  id " << id << " contained twice in data.osm\n";
-            exit(1);
+            std::exit(1);
         }
     }
 
@@ -59,15 +59,15 @@ class CheckBasicsHandler : public osmium::handler::Handler {
     ~CheckBasicsHandler() {
         if (m_num_nodes != 0) {
             std::cerr << "  wrong number of nodes in data.osm\n";
-            exit(1);
+            std::exit(1);
         }
         if (m_num_ways != 0) {
             std::cerr << "  wrong number of ways in data.osm\n";
-            exit(1);
+            std::exit(1);
         }
         if (m_num_relations != 0) {
             std::cerr << "  wrong number of relations in data.osm\n";
-            exit(1);
+            std::exit(1);
         }
     }
 
diff --git a/third_party/libosmium/test/data-tests/include/check_wkt_handler.hpp b/third_party/libosmium/test/data-tests/include/check_wkt_handler.hpp
index fe0199e0aca..e715b597da2 100644
--- a/third_party/libosmium/test/data-tests/include/check_wkt_handler.hpp
+++ b/third_party/libosmium/test/data-tests/include/check_wkt_handler.hpp
@@ -17,25 +17,25 @@ class CheckWKTHandler : public osmium::handler::Handler {
     osmium::geom::WKTFactory<> m_factory;
 
     void read_wkt_file(const std::string& filename) {
-        std::ifstream in(filename, std::ifstream::in);
+        std::ifstream in{filename, std::ifstream::in};
         if (in) {
             osmium::object_id_type id;
             std::string line;
             while (std::getline(in, line)) {
-                size_t pos = line.find_first_of(' ');
+                const std::size_t pos = line.find_first_of(' ');
 
                 if (pos == std::string::npos) {
                     std::cerr << filename << " not formatted correctly\n";
-                    exit(1);
+                    std::exit(1);
                 }
 
                 std::string id_str = line.substr(0, pos);
-                std::istringstream iss(id_str);
+                std::istringstream iss{id_str};
                 iss >> id;
 
                 if (m_geometries.find(id) != m_geometries.end()) {
                      std::cerr << filename + " contains id " << id << "twice\n";
-                     exit(1);
+                     std::exit(1);
                 }
 
                 m_geometries[id] = line.substr(pos+1);
@@ -58,7 +58,7 @@ class CheckWKTHandler : public osmium::handler::Handler {
             for (const auto& geom : m_geometries) {
                 std::cerr << "geometry id " << geom.first << " not in data.osm.\n";
             }
-            exit(1);
+            std::exit(1);
         }
     }
 
@@ -66,7 +66,7 @@ class CheckWKTHandler : public osmium::handler::Handler {
         const std::string wkt = m_geometries[node.id()];
         assert(wkt != "" && "Missing geometry for node in nodes.wkt");
 
-        std::string this_wkt = m_factory.create_point(node.location());
+        const std::string this_wkt = m_factory.create_point(node.location());
         assert(wkt == this_wkt && "wkt geometries don't match");
         m_geometries.erase(node.id());
     }
@@ -75,8 +75,10 @@ class CheckWKTHandler : public osmium::handler::Handler {
         const std::string wkt = m_geometries[way.id()];
         assert(wkt != "" && "Missing geometry for way in ways.wkt");
 
-        std::string this_wkt = m_factory.create_linestring(way);
-        assert(wkt == this_wkt && "wkt geometries don't match");
+        if (wkt != "NULL") {
+            const std::string this_wkt = m_factory.create_linestring(way);
+            assert(wkt == this_wkt && "wkt geometries don't match");
+        }
         m_geometries.erase(way.id());
     }
 
diff --git a/third_party/libosmium/test/data-tests/run-testdata-multipolygon.cmake b/third_party/libosmium/test/data-tests/run-testdata-multipolygon.cmake
index 0d08f5a525e..be2cb395dda 100644
--- a/third_party/libosmium/test/data-tests/run-testdata-multipolygon.cmake
+++ b/third_party/libosmium/test/data-tests/run-testdata-multipolygon.cmake
@@ -14,8 +14,7 @@ file(REMOVE multipolygon.db multipolygon-tests.json)
 #
 #-----------------------------------------------------------------------------
 execute_process(
-    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/testdata-multipolygon
-        ${OSM_TESTDATA}/grid/data/all.osm
+    COMMAND ${EXECUTABLE} ${OSM_TESTDATA}/grid/data/all.osm
     RESULT_VARIABLE _result
     OUTPUT_FILE multipolygon.log
     ERROR_FILE multipolygon.log
diff --git a/third_party/libosmium/test/data-tests/testcases/test-100.cpp b/third_party/libosmium/test/data-tests/testcases/test-100.cpp
index df616429b1b..29174daa494 100644
--- a/third_party/libosmium/test/data-tests/testcases/test-100.cpp
+++ b/third_party/libosmium/test/data-tests/testcases/test-100.cpp
@@ -1,5 +1,4 @@
 
-#include <cmath>
 #include <cstring>
 #include <stdexcept>
 
@@ -13,7 +12,7 @@ class TestHandler100 : public osmium::handler::Handler {
         osmium::handler::Handler() {
     }
 
-    void node(const osmium::Node& node) {
+    void node(const osmium::Node& node) const {
         constexpr const double epsilon = 0.00000001;
         if (node.id() == 100000) {
             REQUIRE(node.version() == 1);
@@ -21,8 +20,8 @@ class TestHandler100 : public osmium::handler::Handler {
             REQUIRE(node.uid() == 1);
             REQUIRE(!std::strcmp(node.user(), "test"));
             REQUIRE(node.changeset() == 1);
-            REQUIRE(std::abs(node.location().lon() - 1.02) < epsilon);
-            REQUIRE(std::abs(node.location().lat() - 1.02) < epsilon);
+            REQUIRE(node.location().lon() == Approx(1.02).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.02).epsilon(epsilon));
         } else {
             throw std::runtime_error{"Unknown ID"};
         }
@@ -31,16 +30,12 @@ class TestHandler100 : public osmium::handler::Handler {
 }; // class TestHandler100
 
 TEST_CASE("100") {
+    osmium::io::Reader reader{dirname + "/1/100/data.osm"};
 
-    SECTION("test 100") {
-        osmium::io::Reader reader{dirname + "/1/100/data.osm"};
-
-        CheckBasicsHandler check_basics_handler{100, 1, 0, 0};
-        CheckWKTHandler check_wkt_handler{dirname, 100};
-        TestHandler100 test_handler;
-
-        osmium::apply(reader, check_basics_handler, check_wkt_handler, test_handler);
-    }
+    CheckBasicsHandler check_basics_handler{100, 1, 0, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 100};
+    TestHandler100 test_handler;
 
+    osmium::apply(reader, check_basics_handler, check_wkt_handler, test_handler);
 }
 
diff --git a/third_party/libosmium/test/data-tests/testcases/test-101.cpp b/third_party/libosmium/test/data-tests/testcases/test-101.cpp
index 1693a71ff10..02f5254cf6f 100644
--- a/third_party/libosmium/test/data-tests/testcases/test-101.cpp
+++ b/third_party/libosmium/test/data-tests/testcases/test-101.cpp
@@ -1,5 +1,4 @@
 
-#include <cmath>
 #include <stdexcept>
 
 #include "common.hpp"
@@ -12,16 +11,16 @@ class TestHandler101 : public osmium::handler::Handler {
         osmium::handler::Handler() {
     }
 
-    void node(const osmium::Node& node) {
+    void node(const osmium::Node& node) const {
         constexpr const double epsilon = 0.00000001;
         if (node.id() == 101000) {
             REQUIRE(node.version() == 1);
-            REQUIRE(std::abs(node.location().lon() - 1.12) < epsilon);
-            REQUIRE(std::abs(node.location().lat() - 1.02) < epsilon);
+            REQUIRE(node.location().lon() == Approx(1.12).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.02).epsilon(epsilon));
         } else if (node.id() == 101001) {
             REQUIRE(node.version() == 1);
-            REQUIRE(std::abs(node.location().lon() - 1.12) < epsilon);
-            REQUIRE(std::abs(node.location().lat() - 1.03) < epsilon);
+            REQUIRE(node.location().lon() == Approx(1.12).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.03).epsilon(epsilon));
         } else if (node.id() == 101002) {
         } else if (node.id() == 101003) {
         } else {
@@ -32,16 +31,12 @@ class TestHandler101 : public osmium::handler::Handler {
 }; // class TestHandler101
 
 TEST_CASE("101") {
+    osmium::io::Reader reader{dirname + "/1/101/data.osm"};
 
-    SECTION("test 101") {
-        osmium::io::Reader reader{dirname + "/1/101/data.osm"};
-
-        CheckBasicsHandler check_basics_handler{101, 4, 0, 0};
-        CheckWKTHandler check_wkt_handler{dirname, 101};
-        TestHandler101 test_handler;
-
-        osmium::apply(reader, check_basics_handler, check_wkt_handler, test_handler);
-    }
+    CheckBasicsHandler check_basics_handler{101, 4, 0, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 101};
+    TestHandler101 test_handler;
 
+    osmium::apply(reader, check_basics_handler, check_wkt_handler, test_handler);
 }
 
diff --git a/third_party/libosmium/test/data-tests/testcases/test-102.cpp b/third_party/libosmium/test/data-tests/testcases/test-102.cpp
new file mode 100644
index 00000000000..03dd9f8b3c1
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-102.cpp
@@ -0,0 +1,44 @@
+
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler102 : public osmium::handler::Handler {
+
+    osmium::Location location;
+
+public:
+
+    TestHandler102() :
+        osmium::handler::Handler() {
+    }
+
+    void node(const osmium::Node& node) {
+        constexpr const double epsilon = 0.00000001;
+        if (node.id() == 102000) {
+            REQUIRE(node.version() == 1);
+            REQUIRE(node.location().lon() == Approx(1.24).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.02).epsilon(epsilon));
+            location = node.location();
+        } else if (node.id() == 102001) {
+            REQUIRE(node.version() == 1);
+            REQUIRE(node.location().lon() == Approx(1.24).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.02).epsilon(epsilon));
+            REQUIRE(node.location() == location);
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler102
+
+TEST_CASE("102") {
+    osmium::io::Reader reader{dirname + "/1/102/data.osm"};
+
+    CheckBasicsHandler check_basics_handler{102, 2, 0, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 102};
+    TestHandler102 test_handler;
+
+    osmium::apply(reader, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-110.cpp b/third_party/libosmium/test/data-tests/testcases/test-110.cpp
index 72fbb4dfb2e..799b47d958c 100644
--- a/third_party/libosmium/test/data-tests/testcases/test-110.cpp
+++ b/third_party/libosmium/test/data-tests/testcases/test-110.cpp
@@ -1,5 +1,4 @@
 
-#include <cmath>
 #include <cstring>
 #include <stdexcept>
 
@@ -13,24 +12,24 @@ class TestHandler110 : public osmium::handler::Handler {
         osmium::handler::Handler() {
     }
 
-    void node(const osmium::Node& node) {
+    void node(const osmium::Node& node) const {
         constexpr const double epsilon = 0.00000001;
         if (node.id() == 110000) {
-            REQUIRE(std::abs(node.location().lon() - 1.02) < epsilon);
-            REQUIRE(std::abs(node.location().lat() - 1.12) < epsilon);
+            REQUIRE(node.location().lon() == Approx(1.02).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.12).epsilon(epsilon));
         } else if (node.id() == 110001) {
-            REQUIRE(std::abs(node.location().lon() - 1.07) < epsilon);
-            REQUIRE(std::abs(node.location().lat() - 1.13) < epsilon);
+            REQUIRE(node.location().lon() == Approx(1.07).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.13).epsilon(epsilon));
         } else {
             throw std::runtime_error{"Unknown ID"};
         }
     }
 
-    void way(const osmium::Way& way) {
+    void way(const osmium::Way& way) const {
         if (way.id() == 110800) {
             REQUIRE(way.version() == 1);
             REQUIRE(way.nodes().size() == 2);
-            REQUIRE(!way.is_closed());
+            REQUIRE_FALSE(way.is_closed());
 
             const char *test_id = way.tags().get_value_by_key("test:id");
             REQUIRE(test_id);
@@ -43,21 +42,17 @@ class TestHandler110 : public osmium::handler::Handler {
 }; // class TestHandler110
 
 TEST_CASE("110") {
+    osmium::io::Reader reader{dirname + "/1/110/data.osm"};
 
-    SECTION("test 110") {
-        osmium::io::Reader reader(dirname + "/1/110/data.osm");
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
 
-        index_pos_type index_pos;
-        index_neg_type index_neg;
-        location_handler_type location_handler(index_pos, index_neg);
-        location_handler.ignore_errors();
-
-        CheckBasicsHandler check_basics_handler(110, 2, 1, 0);
-        CheckWKTHandler check_wkt_handler(dirname, 110);
-        TestHandler110 test_handler;
-
-        osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
-    }
+    CheckBasicsHandler check_basics_handler{110, 2, 1, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 110};
+    TestHandler110 test_handler;
 
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
 }
 
diff --git a/third_party/libosmium/test/data-tests/testcases/test-111.cpp b/third_party/libosmium/test/data-tests/testcases/test-111.cpp
new file mode 100644
index 00000000000..4237b3ebf5e
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-111.cpp
@@ -0,0 +1,45 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler111 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler111() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 111800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 4);
+            REQUIRE_FALSE(way.is_closed());
+
+            const char *test_id = way.tags().get_value_by_key("test:id");
+            REQUIRE(test_id);
+            REQUIRE(!std::strcmp(test_id, "111"));
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler111
+
+TEST_CASE("111") {
+    osmium::io::Reader reader{dirname + "/1/111/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{111, 4, 1, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 111};
+    TestHandler111 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-112.cpp b/third_party/libosmium/test/data-tests/testcases/test-112.cpp
new file mode 100644
index 00000000000..977f330c3b7
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-112.cpp
@@ -0,0 +1,45 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler112 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler112() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 112800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 5);
+            REQUIRE(way.is_closed());
+
+            const char *test_id = way.tags().get_value_by_key("test:id");
+            REQUIRE(test_id);
+            REQUIRE(!std::strcmp(test_id, "112"));
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler112
+
+TEST_CASE("112") {
+    osmium::io::Reader reader{dirname + "/1/112/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{112, 4, 1, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 112};
+    TestHandler112 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-113.cpp b/third_party/libosmium/test/data-tests/testcases/test-113.cpp
new file mode 100644
index 00000000000..8c88c64a81d
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-113.cpp
@@ -0,0 +1,68 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler113 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler113() :
+        osmium::handler::Handler() {
+    }
+
+    void node(const osmium::Node& node) const {
+        constexpr const double epsilon = 0.00000001;
+        if (node.id() == 113000) {
+            REQUIRE(node.location().lon() == Approx(1.32).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.12).epsilon(epsilon));
+        } else if (node.id() == 113001) {
+            REQUIRE(node.location().lon() == Approx(1.34).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.13).epsilon(epsilon));
+        } else if (node.id() == 113002) {
+            REQUIRE(node.location().lon() == Approx(1.37).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.12).epsilon(epsilon));
+        } else if (node.id() == 113003) {
+            REQUIRE(node.location().lon() == Approx(1.38).epsilon(epsilon));
+            REQUIRE(node.location().lat() == Approx(1.18).epsilon(epsilon));
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 113800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE_FALSE(way.is_closed());
+            REQUIRE(way.nodes()[0].ref() == 113000);
+            REQUIRE(way.nodes()[1].ref() == 113001);
+        } else if (way.id() == 113801) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE_FALSE(way.is_closed());
+            REQUIRE(way.nodes()[0].ref() == 113002);
+            REQUIRE(way.nodes()[1].ref() == 113003);
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler113
+
+TEST_CASE("113") {
+    osmium::io::Reader reader{dirname + "/1/113/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{113, 4, 2, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 113};
+    TestHandler113 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-114.cpp b/third_party/libosmium/test/data-tests/testcases/test-114.cpp
new file mode 100644
index 00000000000..4d111489783
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-114.cpp
@@ -0,0 +1,49 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler114 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler114() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 114800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE_FALSE(way.is_closed());
+            REQUIRE(way.nodes()[0].ref() == 114000);
+            REQUIRE(way.nodes()[1].ref() == 114001);
+        } else if (way.id() == 114801) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE_FALSE(way.is_closed());
+            REQUIRE(way.nodes()[0].ref() == 114001);
+            REQUIRE(way.nodes()[1].ref() == 114002);
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler114
+
+TEST_CASE("114") {
+    osmium::io::Reader reader{dirname + "/1/114/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{114, 3, 2, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 114};
+    TestHandler114 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-115.cpp b/third_party/libosmium/test/data-tests/testcases/test-115.cpp
new file mode 100644
index 00000000000..34af2dfa861
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-115.cpp
@@ -0,0 +1,49 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler115 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler115() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 115800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE_FALSE(way.is_closed());
+            REQUIRE(way.nodes()[0].ref() == 115000);
+            REQUIRE(way.nodes()[1].ref() == 115001);
+        } else if (way.id() == 115801) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE_FALSE(way.is_closed());
+            REQUIRE(way.nodes()[0].ref() == 115002);
+            REQUIRE(way.nodes()[1].ref() == 115001);
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler115
+
+TEST_CASE("115") {
+    osmium::io::Reader reader{dirname + "/1/115/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{115, 3, 2, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 115};
+    TestHandler115 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-116.cpp b/third_party/libosmium/test/data-tests/testcases/test-116.cpp
new file mode 100644
index 00000000000..7333edd226a
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-116.cpp
@@ -0,0 +1,47 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler116 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler116() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 116800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE_FALSE(way.is_closed());
+            REQUIRE(way.nodes()[0].ref() == 116000);
+            REQUIRE(way.nodes()[1].ref() == 116001);
+        } else if (way.id() == 116801) {
+            REQUIRE(way.nodes().size() == 2);
+        } else if (way.id() == 116802) {
+            REQUIRE(way.nodes().size() == 4);
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler116
+
+TEST_CASE("116") {
+    osmium::io::Reader reader{dirname + "/1/116/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{116, 5, 3, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 116};
+    TestHandler116 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-120.cpp b/third_party/libosmium/test/data-tests/testcases/test-120.cpp
new file mode 100644
index 00000000000..d4e0da8df64
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-120.cpp
@@ -0,0 +1,39 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler120 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler120() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 120800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().empty());
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler120
+
+TEST_CASE("120") {
+    osmium::io::Reader reader{dirname + "/1/120/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{120, 0, 1, 0};
+    TestHandler120 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-121.cpp b/third_party/libosmium/test/data-tests/testcases/test-121.cpp
new file mode 100644
index 00000000000..301d61d7db1
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-121.cpp
@@ -0,0 +1,40 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler121 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler121() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 121800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 1);
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler121
+
+TEST_CASE("121") {
+    osmium::io::Reader reader{dirname + "/1/121/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{121, 1, 1, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 121};
+    TestHandler121 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-122.cpp b/third_party/libosmium/test/data-tests/testcases/test-122.cpp
new file mode 100644
index 00000000000..d0b9a343bf7
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-122.cpp
@@ -0,0 +1,41 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler122 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler122() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 122800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE(way.nodes()[0] == way.nodes()[1]);
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler122
+
+TEST_CASE("122") {
+    osmium::io::Reader reader{dirname + "/1/122/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{122, 1, 1, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 122};
+    TestHandler122 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-123.cpp b/third_party/libosmium/test/data-tests/testcases/test-123.cpp
new file mode 100644
index 00000000000..dcd24d5a9b9
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-123.cpp
@@ -0,0 +1,42 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler123 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler123() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 123800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 2);
+            REQUIRE(way.nodes()[0] != way.nodes()[1]);
+            REQUIRE(way.nodes()[0].location() == way.nodes()[1].location());
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler123
+
+TEST_CASE("123") {
+    osmium::io::Reader reader{dirname + "/1/123/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{123, 2, 1, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 123};
+    TestHandler123 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testcases/test-124.cpp b/third_party/libosmium/test/data-tests/testcases/test-124.cpp
new file mode 100644
index 00000000000..0a01e379d3d
--- /dev/null
+++ b/third_party/libosmium/test/data-tests/testcases/test-124.cpp
@@ -0,0 +1,44 @@
+
+#include <cstring>
+#include <stdexcept>
+
+#include "common.hpp"
+
+class TestHandler124 : public osmium::handler::Handler {
+
+public:
+
+    TestHandler124() :
+        osmium::handler::Handler() {
+    }
+
+    void way(const osmium::Way& way) const {
+        if (way.id() == 124800) {
+            REQUIRE(way.version() == 1);
+            REQUIRE(way.nodes().size() == 3);
+            REQUIRE(way.nodes()[0] != way.nodes()[1]);
+            REQUIRE(way.nodes()[0].location() == way.nodes()[1].location());
+            REQUIRE(way.nodes()[0] != way.nodes()[2]);
+            REQUIRE(way.nodes()[0].location() != way.nodes()[2].location());
+        } else {
+            throw std::runtime_error{"Unknown ID"};
+        }
+    }
+
+}; // class TestHandler124
+
+TEST_CASE("124") {
+    osmium::io::Reader reader{dirname + "/1/124/data.osm"};
+
+    index_pos_type index_pos;
+    index_neg_type index_neg;
+    location_handler_type location_handler{index_pos, index_neg};
+    location_handler.ignore_errors();
+
+    CheckBasicsHandler check_basics_handler{124, 3, 1, 0};
+    CheckWKTHandler check_wkt_handler{dirname, 124};
+    TestHandler124 test_handler;
+
+    osmium::apply(reader, location_handler, check_basics_handler, check_wkt_handler, test_handler);
+}
+
diff --git a/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp b/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp
index 06385fb2b07..d3b4c0e4184 100644
--- a/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp
@@ -1,14 +1,4 @@
 
-#include <cstring>
-#include <iostream>
-#include <fstream>
-#include <map>
-#include <string>
-
-#include <gdalcpp.hpp>
-
-#include <osmium/index/map/sparse_mem_array.hpp>
-
 #include <osmium/area/assembler_legacy.hpp>
 #include <osmium/area/multipolygon_collector.hpp>
 #include <osmium/area/problem_reporter_ogr.hpp>
@@ -16,9 +6,18 @@
 #include <osmium/geom/wkt.hpp>
 #include <osmium/handler.hpp>
 #include <osmium/handler/node_locations_for_ways.hpp>
+#include <osmium/index/map/sparse_mem_array.hpp>
 #include <osmium/io/xml_input.hpp>
 #include <osmium/visitor.hpp>
 
+#include <gdalcpp.hpp>
+
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <string>
+
 using index_type = osmium::index::map::SparseMemArray<osmium::unsigned_object_id_type, osmium::Location>;
 using location_handler_type = osmium::handler::NodeLocationsForWays<index_type>;
 
@@ -73,6 +72,12 @@ class TestHandler : public osmium::handler::Handler {
         m_layer_mpoly.add_field("from_type", OFTString, 1);
     }
 
+    TestHandler(const TestHandler&) = delete;
+    TestHandler& operator=(const TestHandler&) = delete;
+
+    TestHandler(TestHandler&&) = delete;
+    TestHandler& operator=(TestHandler&&) = delete;
+
     ~TestHandler() {
         m_out << "\n]\n";
     }
diff --git a/third_party/libosmium/test/data-tests/testdata-overview.cpp b/third_party/libosmium/test/data-tests/testdata-overview.cpp
index 4994f23efa1..8c88f5b6438 100644
--- a/third_party/libosmium/test/data-tests/testdata-overview.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-overview.cpp
@@ -1,18 +1,17 @@
 /* The code in this file is released into the Public Domain. */
 
-#include <iostream>
-#include <string>
-
-#include <gdalcpp.hpp>
-
-#include <osmium/index/map/sparse_mem_array.hpp>
-
 #include <osmium/geom/ogr.hpp>
 #include <osmium/handler.hpp>
 #include <osmium/handler/node_locations_for_ways.hpp>
+#include <osmium/index/map/sparse_mem_array.hpp>
 #include <osmium/io/xml_input.hpp>
 #include <osmium/visitor.hpp>
 
+#include <gdalcpp.hpp>
+
+#include <iostream>
+#include <string>
+
 using index_type = osmium::index::map::SparseMemArray<osmium::unsigned_object_id_type, osmium::Location>;
 using location_handler_type = osmium::handler::NodeLocationsForWays<index_type>;
 
diff --git a/third_party/libosmium/test/data-tests/testdata-testcases.cpp b/third_party/libosmium/test/data-tests/testdata-testcases.cpp
index d05c28327a4..3c5f19e9626 100644
--- a/third_party/libosmium/test/data-tests/testdata-testcases.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-testcases.cpp
@@ -1,11 +1,11 @@
 
-#include <iostream>
-#include <string>
-
 #define CATCH_CONFIG_RUNNER
 
 #include "testdata-testcases.hpp"
 
+#include <iostream>
+#include <string>
+
 std::string dirname;
 
 int main(int argc, char* argv[]) {
diff --git a/third_party/libosmium/test/data-tests/testdata-xml.cpp b/third_party/libosmium/test/data-tests/testdata-xml.cpp
index 0808d3fb53e..16f78cba7a7 100644
--- a/third_party/libosmium/test/data-tests/testdata-xml.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-xml.cpp
@@ -3,18 +3,20 @@
 #define CATCH_CONFIG_MAIN
 #include "catch.hpp"
 
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/io/gzip_compression.hpp>
+#include <osmium/io/xml_input.hpp>
+#include <osmium/util/misc.hpp>
+#include <osmium/visitor.hpp>
+
 #include <cassert>
 #include <cstdlib>
+#include <cstring>
 #include <future>
 #include <iostream>
 #include <iterator>
 #include <string>
 
-#include <osmium/io/detail/queue_util.hpp>
-#include <osmium/io/xml_input.hpp>
-#include <osmium/io/gzip_compression.hpp>
-#include <osmium/visitor.hpp>
-
 static std::string S_(const char* s) {
     return std::string{s};
 }
@@ -115,6 +117,19 @@ static header_buffer_type read_xml(const char* test_id) {
     return parse_xml(input);
 }
 
+template <typename TException>
+void test_fail(const char* xml_file_name, const char* errmsg) {
+    REQUIRE_THROWS_AS(read_xml(xml_file_name), const TException&);
+    REQUIRE_THROWS_WITH(read_xml(xml_file_name), errmsg);
+
+    REQUIRE_THROWS_AS([&](){
+        osmium::io::Reader reader{filename(xml_file_name)};
+        const osmium::io::Header header{reader.header()};
+        osmium::memory::Buffer buffer = reader.read();
+        reader.close();
+    }(), const TException&);
+}
+
 // =============================================
 
 TEST_CASE("Reading OSM XML 100: Direct") {
@@ -122,7 +137,7 @@ TEST_CASE("Reading OSM XML 100: Direct") {
 
     REQUIRE(r.header.get("generator") == "testdata");
     REQUIRE(0 == r.buffer.committed());
-    REQUIRE(! r.buffer);
+    REQUIRE_FALSE(r.buffer);
 }
 
 TEST_CASE("Reading OSM XML 100: Using Reader") {
@@ -133,7 +148,7 @@ TEST_CASE("Reading OSM XML 100: Using Reader") {
 
     osmium::memory::Buffer buffer = reader.read();
     REQUIRE(0 == buffer.committed());
-    REQUIRE(! buffer);
+    REQUIRE_FALSE(buffer);
     reader.close();
 }
 
@@ -147,8 +162,9 @@ TEST_CASE("Reading OSM XML 100: Using Reader asking for header only") {
 
 // =============================================
 
-TEST_CASE("Reading OSM XML 101: Direct") {
-    REQUIRE_THROWS_AS(read_xml("101-missing_version"), osmium::format_version_error);
+TEST_CASE("Reading OSM XML 101") {
+    test_fail<osmium::format_version_error>("101-missing_version", "Can not read file without version (missing version attribute on osm element).");
+
     try {
         read_xml("101-missing_version");
     } catch (const osmium::format_version_error& e) {
@@ -156,19 +172,11 @@ TEST_CASE("Reading OSM XML 101: Direct") {
     }
 }
 
-TEST_CASE("Reading OSM XML 101: Using Reader") {
-    REQUIRE_THROWS_AS([](){
-        osmium::io::Reader reader{filename("101-missing_version")};
-        const osmium::io::Header header{reader.header()};
-        osmium::memory::Buffer buffer = reader.read();
-        reader.close();
-    }(), osmium::format_version_error);
-}
-
 // =============================================
 
-TEST_CASE("Reading OSM XML 102: Direct") {
-    REQUIRE_THROWS_AS(read_xml("102-wrong_version"), osmium::format_version_error);
+TEST_CASE("Reading OSM XML 102") {
+    test_fail<osmium::format_version_error>("102-wrong_version", "Can not read file with version 0.1");
+
     try {
         read_xml("102-wrong_version");
     } catch (const osmium::format_version_error& e) {
@@ -176,20 +184,11 @@ TEST_CASE("Reading OSM XML 102: Direct") {
     }
 }
 
-TEST_CASE("Reading OSM XML 102: Using Reader") {
-    REQUIRE_THROWS_AS([](){
-        osmium::io::Reader reader{filename("102-wrong_version")};
-
-        const osmium::io::Header header{reader.header()};
-        osmium::memory::Buffer buffer = reader.read();
-        reader.close();
-    }(), osmium::format_version_error);
-}
-
 // =============================================
 
-TEST_CASE("Reading OSM XML 103: Direct") {
-    REQUIRE_THROWS_AS(read_xml("103-old_version"), osmium::format_version_error);
+TEST_CASE("Reading OSM XML 103") {
+    test_fail<osmium::format_version_error>("103-old_version", "Can not read file with version 0.5");
+
     try {
         read_xml("103-old_version");
     } catch (const osmium::format_version_error& e) {
@@ -197,19 +196,11 @@ TEST_CASE("Reading OSM XML 103: Direct") {
     }
 }
 
-TEST_CASE("Reading OSM XML 103: Using Reader") {
-    REQUIRE_THROWS_AS([](){
-        osmium::io::Reader reader{filename("103-old_version")};
-        const osmium::io::Header header{reader.header()};
-        osmium::memory::Buffer buffer = reader.read();
-        reader.close();
-    }(), osmium::format_version_error);
-}
-
 // =============================================
 
-TEST_CASE("Reading OSM XML 104: Direct") {
-    REQUIRE_THROWS_AS(read_xml("104-empty_file"), osmium::xml_error);
+TEST_CASE("Reading OSM XML 104") {
+    test_fail<osmium::xml_error>("104-empty_file", "XML parsing error at line 1, column 0: no element found");
+
     try {
         read_xml("104-empty_file");
     } catch (const osmium::xml_error& e) {
@@ -218,28 +209,49 @@ TEST_CASE("Reading OSM XML 104: Direct") {
     }
 }
 
-TEST_CASE("Reading OSM XML 104: Using Reader") {
-    REQUIRE_THROWS_AS([](){
-        osmium::io::Reader reader{filename("104-empty_file")};
-        const osmium::io::Header header{reader.header()};
-        osmium::memory::Buffer buffer = reader.read();
-        reader.close();
-    }(), osmium::xml_error);
+// =============================================
+
+TEST_CASE("Reading OSM XML 105") {
+    test_fail<osmium::xml_error>("105-incomplete_xml_file", "XML parsing error at line 3, column 0: no element found");
 }
 
 // =============================================
 
-TEST_CASE("Reading OSM XML 105: Direct") {
-    REQUIRE_THROWS_AS(read_xml("105-incomplete_xml_file"), osmium::xml_error);
+TEST_CASE("Reading OSM XML 106") {
+    test_fail<osmium::xml_error>("106-invalid_xml_file", "xml file nested too deep");
 }
 
-TEST_CASE("Reading OSM XML 105: Using Reader") {
-    REQUIRE_THROWS_AS([](){
-        osmium::io::Reader reader{filename("105-incomplete_xml_file")};
-        const osmium::io::Header header{reader.header()};
-        osmium::memory::Buffer buffer = reader.read();
-        reader.close();
-    }(), osmium::xml_error);
+// =============================================
+
+TEST_CASE("Reading OSM XML 107") {
+    test_fail<osmium::xml_error>("107-wrongly_nested_xml_file", "Unknown element in <node>: modify");
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 108") {
+    test_fail<osmium::xml_error>("108-unknown_top_level", "Unknown top-level element: foo");
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 109: Direct") {
+    read_xml("109-unknown_data_level");
+}
+
+TEST_CASE("Reading OSM XML 109: Using Reader") {
+    osmium::io::Reader reader{filename("109-unknown_data_level")};
+
+    const osmium::io::Header header{reader.header()};
+    osmium::memory::Buffer buffer = reader.read();
+    REQUIRE(buffer.committed() > 0);
+    reader.close();
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 110") {
+    test_fail<osmium::xml_error>("110-entity_declaration", "XML entities are not supported");
 }
 
 // =============================================
@@ -252,7 +264,7 @@ TEST_CASE("Reading OSM XML 120: Direct") {
     header_buffer_type r = parse_xml(data);
     REQUIRE(r.header.get("generator") == "testdata");
     REQUIRE(0 == r.buffer.committed());
-    REQUIRE(! r.buffer);
+    REQUIRE_FALSE(r.buffer);
 }
 
 TEST_CASE("Reading OSM XML 120: Using Reader") {
@@ -263,14 +275,14 @@ TEST_CASE("Reading OSM XML 120: Using Reader") {
 
     osmium::memory::Buffer buffer = reader.read();
     REQUIRE(0 == buffer.committed());
-    REQUIRE(! buffer);
+    REQUIRE_FALSE(buffer);
     reader.close();
 }
 
 // =============================================
 
 TEST_CASE("Reading OSM XML 121: Direct") {
-    REQUIRE_THROWS_AS(read_gz_file("121-truncated_gzip_file", "osm.gz"), osmium::gzip_error);
+    REQUIRE_THROWS_AS(read_gz_file("121-truncated_gzip_file", "osm.gz"), const osmium::gzip_error&);
 }
 
 TEST_CASE("Reading OSM XML 121: Using Reader") {
@@ -285,17 +297,44 @@ TEST_CASE("Reading OSM XML 121: Using Reader") {
 
 // =============================================
 
-TEST_CASE("Reading OSM XML 122: Direct") {
-    REQUIRE_THROWS_AS(read_xml("122-no_osm_element"), osmium::xml_error);
+TEST_CASE("Reading OSM XML 122") {
+    test_fail<osmium::xml_error>("122-no_osm_element", "Unknown top-level element: node");
 }
 
-TEST_CASE("Reading OSM XML 122: Using Reader") {
-    REQUIRE_THROWS_AS([](){
-        osmium::io::Reader reader{filename("122-no_osm_element")};
-        const osmium::io::Header header{reader.header()};
-        osmium::memory::Buffer buffer = reader.read();
-        reader.close();
-    }(), osmium::xml_error);
+// =============================================
+
+TEST_CASE("Reading OSM XML 123") {
+    test_fail<osmium::xml_error>("123-unknown_element_in_node", "Unknown element in <node>: nd");
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 124") {
+    test_fail<osmium::xml_error>("124-unknown_element_in_way", "Unknown element in <way>: member");
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 125") {
+    test_fail<osmium::xml_error>("125-unknown_element_in_relation", "Unknown element in <relation>: nd");
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 126") {
+    test_fail<osmium::xml_error>("126-wrong_member_type", "Unknown type on relation <member>");
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 127") {
+    test_fail<osmium::xml_error>("127-missing_member_type", "Unknown type on relation <member>");
+}
+
+// =============================================
+
+TEST_CASE("Reading OSM XML 128") {
+    test_fail<osmium::xml_error>("128-missing_member_ref", "Missing ref on relation <member>");
 }
 
 // =============================================
@@ -313,8 +352,8 @@ TEST_CASE("Reading OSM XML 140: Using Reader") {
 
         const char* uc = t["unicode_char"];
 
-        const auto len = atoi(t["unicode_utf8_length"]);
-        REQUIRE(len == strlen(uc));
+        const auto len = osmium::detail::str_to_int<std::size_t>(t["unicode_utf8_length"]);
+        REQUIRE(len == std::strlen(uc));
 
         REQUIRE(S_(uc) == t["unicode_xml"]);
 
@@ -322,7 +361,7 @@ TEST_CASE("Reading OSM XML 140: Using Reader") {
 #if !defined(_MSC_VER)
         switch (count) {
             case 1:
-                REQUIRE(S_(uc) ==  u8"a");
+                REQUIRE(S_(uc) == u8"a");
                 break;
             case 2:
                 REQUIRE(S_(uc) == u8"\u00e4");
@@ -508,7 +547,34 @@ TEST_CASE("Reading OSM XML 200: Using Reader asking for ways") {
 
     osmium::memory::Buffer buffer = reader.read();
     REQUIRE(0 == buffer.committed());
-    REQUIRE(! buffer);
+    REQUIRE_FALSE(buffer);
+    reader.close();
+}
+
+TEST_CASE("Reading OSM XML 300: Change file") {
+    osmium::io::Reader reader{filename("300-change-file", "osc")};
+
+    const osmium::io::Header header{reader.header()};
+    REQUIRE(header.get("generator") == "testdata");
+
+    osmium::memory::Buffer buffer = reader.read();
+
+    auto it = buffer.select<osmium::Node>().begin();
+    REQUIRE(it != buffer.select<osmium::Node>().end());
+    REQUIRE(it->id() == 11);
+    REQUIRE(it->visible());
+
+    ++it;
+    REQUIRE(it->id() == 13);
+    REQUIRE_FALSE(it->visible());
+
+    ++it;
+    REQUIRE(it->id() == 14);
+    REQUIRE(it->visible());
+
+    ++it;
+    REQUIRE(it == buffer.select<osmium::Node>().end());
+
     reader.close();
 }
 
diff --git a/third_party/libosmium/test/examples/t/area_test/CMakeLists.txt b/third_party/libosmium/test/examples/t/area_test/CMakeLists.txt
index 81899a1618d..d92aa97523a 100644
--- a/third_party/libosmium/test/examples/t/area_test/CMakeLists.txt
+++ b/third_party/libosmium/test/examples/t/area_test/CMakeLists.txt
@@ -6,7 +6,7 @@ set_tests_properties(examples_area_test_help PROPERTIES
                      PASS_REGULAR_EXPRESSION "^osmium_area_test .* OSMFILE")
 
 add_test(NAME examples_area_test_data
-         COMMAND osmium_area_test ${CMAKE_CURRENT_SOURCE_DIR}/data.osm)
+         COMMAND osmium_area_test -o ${CMAKE_CURRENT_SOURCE_DIR}/data.osm)
 
 set_tests_properties(examples_area_test_data PROPERTIES
                      PASS_REGULAR_EXPRESSION "\nWarning! Some member ways missing for these multipolygon relations: 701901\n$")
diff --git a/third_party/libosmium/test/examples/t/convert/CMakeLists.txt b/third_party/libosmium/test/examples/t/convert/CMakeLists.txt
index a5f06fa2e8e..ac6f84631f9 100644
--- a/third_party/libosmium/test/examples/t/convert/CMakeLists.txt
+++ b/third_party/libosmium/test/examples/t/convert/CMakeLists.txt
@@ -10,7 +10,7 @@ add_test(NAME examples_convert_xml_debug
          COMMAND osmium_convert -t debug ${CMAKE_CURRENT_SOURCE_DIR}/data.osm)
 
 set_tests_properties(examples_convert_xml_debug PROPERTIES
-                     PASS_REGULAR_EXPRESSION "node 701000\n  version:   1 visible")
+                     PASS_REGULAR_EXPRESSION "node 701000 visible\n  version:   1")
 
 
 add_test(NAME examples_convert_xml_opl
@@ -20,6 +20,20 @@ set_tests_properties(examples_convert_xml_opl PROPERTIES
                      PASS_REGULAR_EXPRESSION "n701001 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x7.11 y1.04")
 
 
+add_test(NAME examples_convert_xml_opl_long1
+         COMMAND osmium_convert --from-format osm --to-format opl ${CMAKE_CURRENT_SOURCE_DIR}/data.osm)
+
+set_tests_properties(examples_convert_xml_opl_long1 PROPERTIES
+                     PASS_REGULAR_EXPRESSION "n701001 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x7.11 y1.04")
+
+
+add_test(NAME examples_convert_xml_opl_long2
+         COMMAND osmium_convert --from-format=osm --to-format=opl ${CMAKE_CURRENT_SOURCE_DIR}/data.osm)
+
+set_tests_properties(examples_convert_xml_opl_long2 PROPERTIES
+                     PASS_REGULAR_EXPRESSION "n701001 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x7.11 y1.04")
+
+
 add_test(NAME examples_convert_xml_pbf
          COMMAND osmium_convert -t pbf ${CMAKE_CURRENT_SOURCE_DIR}/data.osm -)
 
diff --git a/third_party/libosmium/test/t/area/test_assembler.cpp b/third_party/libosmium/test/t/area/test_assembler.cpp
index e25ad0f0208..6378aa9ea83 100644
--- a/third_party/libosmium/test/t/area/test_assembler.cpp
+++ b/third_party/libosmium/test/t/area/test_assembler.cpp
@@ -5,7 +5,7 @@
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm/area.hpp>
 
-using namespace osmium::builder::attr;
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Build area from way") {
     osmium::memory::Buffer buffer{10240};
diff --git a/third_party/libosmium/test/t/builder/test_attr.cpp b/third_party/libosmium/test/t/builder/test_attr.cpp
index 8767817af90..e0385fe1d47 100644
--- a/third_party/libosmium/test/t/builder/test_attr.cpp
+++ b/third_party/libosmium/test/t/builder/test_attr.cpp
@@ -1,6 +1,10 @@
-
 #include "catch.hpp"
 
+#include <osmium/builder/attr.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm.hpp>
+#include <osmium/osm/types.hpp>
+
 #include <cstdint>
 #include <initializer_list>
 #include <string>
@@ -8,14 +12,9 @@
 #include <utility>
 #include <vector>
 
-#include <osmium/builder/attr.hpp>
-#include <osmium/memory/buffer.hpp>
-#include <osmium/osm.hpp>
-#include <osmium/osm/types.hpp>
-
 TEST_CASE("create node using builders") {
 
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
     osmium::memory::Buffer buffer{1024 * 10};
 
@@ -29,9 +28,9 @@ TEST_CASE("create node using builders") {
         REQUIRE(node.timestamp() == osmium::Timestamp{});
         REQUIRE(node.changeset() == 0);
         REQUIRE(node.uid() == 0);
-        REQUIRE(std::string(node.user()) == "");
+        REQUIRE(std::string{node.user()}.empty());
         REQUIRE(node.location() == osmium::Location{});
-        REQUIRE(node.tags().size() == 0);
+        REQUIRE(node.tags().empty());
     }
 
     SECTION("add node with complete info but no tags") {
@@ -53,9 +52,9 @@ TEST_CASE("create node using builders") {
         REQUIRE(node.timestamp() == osmium::Timestamp{"2015-01-01T10:20:30Z"});
         REQUIRE(node.changeset() == 21);
         REQUIRE(node.uid() == 222);
-        REQUIRE(std::string(node.user()) == "foo");
+        REQUIRE(std::string{node.user()} == "foo");
         REQUIRE(node.location() == loc);
-        REQUIRE(node.tags().size() == 0);
+        REQUIRE(node.tags().empty());
         REQUIRE(std::distance(node.cbegin(), node.cend()) == 0);
     }
 
@@ -84,7 +83,7 @@ TEST_CASE("create node using builders") {
             _version(17),
             _cid(21),
             _uid(222),
-            _user(std::string("foo")),
+            _user(std::string{"foo"}),
             _id(1),
             _location(3.14, 1.59)
         );
@@ -96,11 +95,19 @@ TEST_CASE("create node using builders") {
         REQUIRE(node.timestamp() == osmium::Timestamp{"2015-01-01T10:20:30Z"});
         REQUIRE(node.changeset() == 21);
         REQUIRE(node.uid() == 222);
-        REQUIRE(std::string(node.user()) == "foo");
+        REQUIRE(std::string{node.user()} == "foo");
         REQUIRE(node.location() == loc);
-        REQUIRE(node.tags().size() == 0);
+        REQUIRE(node.tags().empty());
     }
 
+}
+
+TEST_CASE("create node with tags using builders") {
+
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
+
+    osmium::memory::Buffer buffer{1024 * 10};
+
     SECTION("add tags using _tag") {
         std::pair<const char*, const char*> t1 = {"name", "Node Inn"};
         std::pair<std::string, std::string> t2 = {"phone", "+1-123-555-4567"};
@@ -120,17 +127,17 @@ TEST_CASE("create node using builders") {
         REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
 
         auto it = node.tags().cbegin();
-        REQUIRE(std::string(it->key()) == "amenity");
-        REQUIRE(std::string(it->value()) == "restaurant");
+        REQUIRE(std::string{it->key()} == "amenity");
+        REQUIRE(std::string{it->value()} == "restaurant");
         ++it;
-        REQUIRE(std::string(it->key()) == "name");
-        REQUIRE(std::string(it->value()) == "Node Inn");
+        REQUIRE(std::string{it->key()} == "name");
+        REQUIRE(std::string{it->value()} == "Node Inn");
         ++it;
-        REQUIRE(std::string(it->key()) == "phone");
-        REQUIRE(std::string(it->value()) == "+1-123-555-4567");
+        REQUIRE(std::string{it->key()} == "phone");
+        REQUIRE(std::string{it->value()} == "+1-123-555-4567");
         ++it;
-        REQUIRE(std::string(it->key()) == "cuisine");
-        REQUIRE(std::string(it->value()) == "italian");
+        REQUIRE(std::string{it->key()} == "cuisine");
+        REQUIRE(std::string{it->value()} == "italian");
         ++it;
         REQUIRE(it == node.tags().cend());
     }
@@ -147,8 +154,8 @@ TEST_CASE("create node using builders") {
         REQUIRE(node.tags().size() == 1);
 
         auto it = node.tags().cbegin();
-        REQUIRE(std::string(it->key()) == "amenity");
-        REQUIRE(std::string(it->value()) == "post_box");
+        REQUIRE(std::string{it->key()} == "amenity");
+        REQUIRE(std::string{it->value()} == "post_box");
         ++it;
         REQUIRE(it == node.tags().cend());
         REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
@@ -175,9 +182,9 @@ TEST_CASE("create node using builders") {
         REQUIRE(node2.tags().size() == 3);
 
         auto it = node2.tags().cbegin();
-        REQUIRE(std::string(it++->key()) == "a");
-        REQUIRE(std::string(it++->key()) == "b");
-        REQUIRE(std::string(it++->key()) == "c");
+        REQUIRE(std::string{it++->key()} == "a");
+        REQUIRE(std::string{it++->key()} == "b");
+        REQUIRE(std::string{it++->key()} == "c");
         REQUIRE(it == node2.tags().cend());
         REQUIRE(std::distance(node2.cbegin(), node2.cend()) == 1);
     }
@@ -202,17 +209,17 @@ TEST_CASE("create node using builders") {
         REQUIRE(node.tags().size() == 6);
 
         auto it = node.tags().cbegin();
-        REQUIRE(std::string(it->key()) == "t1");
+        REQUIRE(std::string{it->key()} == "t1");
         ++it;
-        REQUIRE(std::string(it->key()) == "t2");
+        REQUIRE(std::string{it->key()} == "t2");
         ++it;
-        REQUIRE(std::string(it->key()) == "t3");
+        REQUIRE(std::string{it->key()} == "t3");
         ++it;
-        REQUIRE(std::string(it->key()) == "t4");
+        REQUIRE(std::string{it->key()} == "t4");
         ++it;
-        REQUIRE(std::string(it->key()) == "t5");
+        REQUIRE(std::string{it->key()} == "t5");
         ++it;
-        REQUIRE(std::string(it->key()) == "t6");
+        REQUIRE(std::string{it->key()} == "t6");
         ++it;
         REQUIRE(it == node.tags().cend());
         REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
@@ -222,7 +229,7 @@ TEST_CASE("create node using builders") {
 
 TEST_CASE("create way using builders") {
 
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
     osmium::memory::Buffer buffer{1024 * 10};
 
@@ -241,9 +248,9 @@ TEST_CASE("create way using builders") {
         REQUIRE(way.timestamp() == osmium::Timestamp{});
         REQUIRE(way.changeset() == 21);
         REQUIRE(way.uid() == 222);
-        REQUIRE(std::string(way.user()) == "foo");
-        REQUIRE(way.tags().size() == 0);
-        REQUIRE(way.nodes().size() == 0);
+        REQUIRE(std::string{way.user()} == "foo");
+        REQUIRE(way.tags().empty());
+        REQUIRE(way.nodes().empty());
         REQUIRE(std::distance(way.cbegin(), way.cend()) == 0);
     }
 
@@ -257,7 +264,7 @@ TEST_CASE("create way with nodes") {
         { 8, osmium::Location{8.8, 0.8} }
     };
 
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
     osmium::memory::Buffer wbuffer{1024 * 10};
     osmium::builder::add_way(wbuffer,
@@ -378,7 +385,7 @@ TEST_CASE("create way with nodes") {
 
 TEST_CASE("create relation using builders") {
 
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
     osmium::memory::Buffer buffer{1024 * 10};
 
@@ -404,27 +411,27 @@ TEST_CASE("create relation using builders") {
 
         REQUIRE(it->type() == osmium::item_type::node);
         REQUIRE(it->ref() == 123);
-        REQUIRE(std::string(it->role()) == "");
+        REQUIRE(std::string{it->role()}.empty());
         ++it;
 
         REQUIRE(it->type() == osmium::item_type::node);
         REQUIRE(it->ref() == 132);
-        REQUIRE(std::string(it->role()) == "");
+        REQUIRE(std::string{it->role()}.empty());
         ++it;
 
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 111);
-        REQUIRE(std::string(it->role()) == "outer");
+        REQUIRE(std::string{it->role()} == "outer");
         ++it;
 
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 112);
-        REQUIRE(std::string(it->role()) == "inner");
+        REQUIRE(std::string{it->role()} == "inner");
         ++it;
 
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 113);
-        REQUIRE(std::string(it->role()) == "inner");
+        REQUIRE(std::string{it->role()} == "inner");
         ++it;
 
         REQUIRE(it == relation.members().end());
@@ -454,12 +461,12 @@ TEST_CASE("create relation using builders") {
 
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 111);
-        REQUIRE(std::string(it->role()) == "outer");
+        REQUIRE(std::string{it->role()} == "outer");
         ++it;
 
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 112);
-        REQUIRE(std::string(it->role()) == "inner");
+        REQUIRE(std::string{it->role()} == "inner");
         ++it;
 
         REQUIRE(it == relation.members().end());
@@ -483,11 +490,11 @@ TEST_CASE("create relation using builders") {
         auto it = relation.members().begin();
         REQUIRE(it->type() == osmium::item_type::node);
         REQUIRE(it->ref() == 123);
-        REQUIRE(std::string(it->role()) == "");
+        REQUIRE(std::string{it->role()}.empty());
         ++it;
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 111);
-        REQUIRE(std::string(it->role()) == "outer");
+        REQUIRE(std::string{it->role()} == "outer");
         ++it;
         REQUIRE(it == relation.members().end());
     }
@@ -525,11 +532,11 @@ TEST_CASE("create relation using builders") {
         auto it = relation.members().begin();
         REQUIRE(it->type() == osmium::item_type::node);
         REQUIRE(it->ref() == 123);
-        REQUIRE(std::string(it->role()) == "");
+        REQUIRE(std::string{it->role()}.empty());
         ++it;
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 111);
-        REQUIRE(std::string(it->role()) == "outer");
+        REQUIRE(std::string{it->role()} == "outer");
         ++it;
         REQUIRE(it == relation.members().end());
     }
@@ -538,7 +545,7 @@ TEST_CASE("create relation using builders") {
 
 TEST_CASE("create area using builders") {
 
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
     osmium::memory::Buffer buffer{1024 * 10};
 
@@ -558,7 +565,7 @@ TEST_CASE("create area using builders") {
         REQUIRE(area.timestamp() == osmium::Timestamp{});
         REQUIRE(area.changeset() == 21);
         REQUIRE(area.uid() == 222);
-        REQUIRE(std::string(area.user()) == "foo");
+        REQUIRE(std::string{area.user()} == "foo");
         REQUIRE(area.tags().size() == 1);
         REQUIRE(std::distance(area.cbegin(), area.cend()) == 1);
     }
diff --git a/third_party/libosmium/test/t/builder/test_object_builder.cpp b/third_party/libosmium/test/t/builder/test_object_builder.cpp
index 3110a38b787..eb7075bd60f 100644
--- a/third_party/libosmium/test/t/builder/test_object_builder.cpp
+++ b/third_party/libosmium/test/t/builder/test_object_builder.cpp
@@ -1,4 +1,3 @@
-
 #include "catch.hpp"
 
 #include <osmium/builder/osm_object_builder.hpp>
diff --git a/third_party/libosmium/test/t/geom/test_exception.cpp b/third_party/libosmium/test/t/geom/test_exception.cpp
index 4122d17c80c..4d2d263c412 100644
--- a/third_party/libosmium/test/t/geom/test_exception.cpp
+++ b/third_party/libosmium/test/t/geom/test_exception.cpp
@@ -1,9 +1,9 @@
 #include "catch.hpp"
 
-#include <string>
-
 #include <osmium/geom/factory.hpp>
 
+#include <string>
+
 TEST_CASE("Geometry exception") {
 
     osmium::geometry_error e{"some error message", "node", 17};
diff --git a/third_party/libosmium/test/t/geom/test_geojson.cpp b/third_party/libosmium/test/t/geom/test_geojson.cpp
index 400bb50f538..24c2bf9fba5 100644
--- a/third_party/libosmium/test/t/geom/test_geojson.cpp
+++ b/third_party/libosmium/test/t/geom/test_geojson.cpp
@@ -1,10 +1,10 @@
 #include "catch.hpp"
 
-#include <osmium/geom/geojson.hpp>
-
 #include "area_helper.hpp"
 #include "wnl_helper.hpp"
 
+#include <osmium/geom/geojson.hpp>
+
 TEST_CASE("GeoJSON point geometry") {
     osmium::geom::GeoJSONFactory<> factory;
 
@@ -80,6 +80,32 @@ TEST_CASE("GeoJSON linestring geometry") {
 
 }
 
+TEST_CASE("GeoJSON polygon geometry") {
+    osmium::geom::GeoJSONFactory<> factory;
+    osmium::memory::Buffer buffer{1000};
+    const auto& wnl = create_test_wnl_closed(buffer);
+
+    SECTION("unique forwards (default)") {
+      const std::string wkt{factory.create_polygon(wnl)};
+      REQUIRE(wkt == "{\"type\":\"Polygon\",\"coordinates\":[[[3,3],[4.1,4.1],[3.6,4.1],[3.1,3.5],[3,3]]]}");
+    }
+
+    SECTION("unique backwards") {
+      const std::string wkt{factory.create_polygon(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward)};
+      REQUIRE(wkt == "{\"type\":\"Polygon\",\"coordinates\":[[[3,3],[3.1,3.5],[3.6,4.1],[4.1,4.1],[3,3]]]}");
+    }
+
+    SECTION("all forwards") {
+      const std::string wkt{factory.create_polygon(wnl,  osmium::geom::use_nodes::all)};
+      REQUIRE(wkt == "{\"type\":\"Polygon\",\"coordinates\":[[[3,3],[4.1,4.1],[4.1,4.1],[3.6,4.1],[3.1,3.5],[3,3]]]}");
+    }
+
+    SECTION("all backwards") {
+      const std::string wkt{factory.create_polygon(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward)};
+      REQUIRE(wkt == "{\"type\":\"Polygon\",\"coordinates\":[[[3,3],[3.1,3.5],[3.6,4.1],[4.1,4.1],[4.1,4.1],[3,3]]]}");
+    }
+}
+
 TEST_CASE("GeoJSON area geometry") {
     osmium::geom::GeoJSONFactory<> factory;
     osmium::memory::Buffer buffer{1000};
diff --git a/third_party/libosmium/test/t/geom/test_geos.cpp b/third_party/libosmium/test/t/geom/test_geos.cpp
index f138616027e..63a583d4364 100644
--- a/third_party/libosmium/test/t/geom/test_geos.cpp
+++ b/third_party/libosmium/test/t/geom/test_geos.cpp
@@ -5,11 +5,11 @@
 
 #include "catch.hpp"
 
-#include <osmium/geom/mercator_projection.hpp>
-
 #include "area_helper.hpp"
 #include "wnl_helper.hpp"
 
+#include <osmium/geom/mercator_projection.hpp>
+
 TEST_CASE("GEOS geometry factory - create point") {
     osmium::geom::GEOSFactory<> factory;
 
@@ -93,7 +93,7 @@ TEST_CASE("GEOS geometry factory - create area with one outer and no inner rings
     const std::unique_ptr<geos::geom::MultiPolygon> mp{factory.create_multipolygon(area)};
     REQUIRE(1 == mp->getNumGeometries());
 
-    const geos::geom::Polygon* p0 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(0));
+    const auto* p0 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(0));
     REQUIRE(p0);
     REQUIRE(0 == p0->getNumInteriorRing());
 
@@ -113,7 +113,7 @@ TEST_CASE("GEOS geometry factory - create area with one outer and one inner ring
     const std::unique_ptr<geos::geom::MultiPolygon> mp{factory.create_multipolygon(area)};
     REQUIRE(1 == mp->getNumGeometries());
 
-    const geos::geom::Polygon* p0 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(0));
+    const auto* p0 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(0));
     REQUIRE(p0);
     REQUIRE(1 == p0->getNumInteriorRing());
 
@@ -133,14 +133,14 @@ TEST_CASE("GEOS geometry factory - create area with two outer and two inner ring
     const std::unique_ptr<geos::geom::MultiPolygon> mp{factory.create_multipolygon(area)};
     REQUIRE(2 == mp->getNumGeometries());
 
-    const geos::geom::Polygon* p0 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(0));
+    const auto* p0 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(0));
     REQUIRE(p0);
     REQUIRE(2 == p0->getNumInteriorRing());
 
     const geos::geom::LineString* l0e = p0->getExteriorRing();
     REQUIRE(5 == l0e->getNumPoints());
 
-    const geos::geom::Polygon* p1 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(1));
+    const auto* p1 = dynamic_cast<const geos::geom::Polygon*>(mp->getGeometryN(1));
     REQUIRE(p1);
     REQUIRE(0 == p1->getNumInteriorRing());
 
diff --git a/third_party/libosmium/test/t/geom/test_ogr.cpp b/third_party/libosmium/test/t/geom/test_ogr.cpp
index 39f2b5c09c6..8fe9c69bd84 100644
--- a/third_party/libosmium/test/t/geom/test_ogr.cpp
+++ b/third_party/libosmium/test/t/geom/test_ogr.cpp
@@ -1,10 +1,10 @@
 #include "catch.hpp"
 
-#include <osmium/geom/ogr.hpp>
-
 #include "area_helper.hpp"
 #include "wnl_helper.hpp"
 
+#include <osmium/geom/ogr.hpp>
+
 TEST_CASE("OGR point geometry") {
     osmium::geom::OGRFactory<> factory;
 
@@ -67,7 +67,7 @@ TEST_CASE("OGR area geometry") {
         std::unique_ptr<OGRMultiPolygon> mp {factory.create_multipolygon(area)};
         REQUIRE(1 == mp->getNumGeometries());
 
-        const OGRPolygon* p0 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(0));
+        const auto* p0 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(0));
         REQUIRE(p0);
         REQUIRE(0 == p0->getNumInteriorRings());
 
@@ -83,7 +83,7 @@ TEST_CASE("OGR area geometry") {
         std::unique_ptr<OGRMultiPolygon> mp {factory.create_multipolygon(area)};
         REQUIRE(1 == mp->getNumGeometries());
 
-        const OGRPolygon* p0 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(0));
+        const auto* p0 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(0));
         REQUIRE(p0);
         REQUIRE(1 == p0->getNumInteriorRings());
 
@@ -100,14 +100,14 @@ TEST_CASE("OGR area geometry") {
         std::unique_ptr<OGRMultiPolygon> mp {factory.create_multipolygon(area)};
         REQUIRE(2 == mp->getNumGeometries());
 
-        const OGRPolygon* p0 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(0));
+        const auto* p0 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(0));
         REQUIRE(p0);
         REQUIRE(2 == p0->getNumInteriorRings());
 
         const OGRLineString* l0e = p0->getExteriorRing();
         REQUIRE(5 == l0e->getNumPoints());
 
-        const OGRPolygon* p1 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(1));
+        const auto* p1 = dynamic_cast<const OGRPolygon*>(mp->getGeometryRef(1));
         REQUIRE(p1);
         REQUIRE(0 == p1->getNumInteriorRings());
 
diff --git a/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp b/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp
index 47d1cdd775c..cf5604999db 100644
--- a/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp
+++ b/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp
@@ -1,14 +1,13 @@
-
 #include "catch.hpp"
 
-#include <memory>
-#include <sstream>
-#include <string>
-
 #include <osmium/geom/ogr.hpp>
 #include <osmium/geom/wkb.hpp>
 #include <osmium/util/endian.hpp>
 
+#include <memory>
+#include <sstream>
+#include <string>
+
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 
 #include "area_helper.hpp"
diff --git a/third_party/libosmium/test/t/geom/test_projection.cpp b/third_party/libosmium/test/t/geom/test_projection.cpp
index bff568b6d69..2b1ba0d47b1 100644
--- a/third_party/libosmium/test/t/geom/test_projection.cpp
+++ b/third_party/libosmium/test/t/geom/test_projection.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
-#include <random>
-
 #include <osmium/geom/factory.hpp>
 #include <osmium/geom/mercator_projection.hpp>
 #include <osmium/geom/projection.hpp>
 
+#include <random>
+
 TEST_CASE("Indentity Projection") {
     osmium::geom::IdentityProjection projection;
     REQUIRE(4326 == projection.epsg());
@@ -108,21 +108,3 @@ TEST_CASE("MercatorProjection") {
     }
 }
 
-TEST_CASE("Compare mercator implementations") {
-    osmium::geom::MercatorProjection projection_merc;
-    osmium::geom::Projection projection_3857{3857};
-
-    SECTION("random coordinates") {
-        std::random_device rd;
-        std::mt19937 gen{rd()};
-        std::uniform_real_distribution<> dis_x{-180.0, 180.0};
-        std::uniform_real_distribution<> dis_y{-90.0, 90.0};
-
-        for (int n = 0; n < 10000; ++n) {
-            const osmium::Location loc{dis_x(gen), dis_y(gen)};
-            REQUIRE(projection_merc(loc).x == Approx(projection_3857(loc).x).epsilon(0.00001));
-            REQUIRE(projection_merc(loc).y == Approx(projection_3857(loc).y).epsilon(0.00001));
-        }
-    }
-
-}
diff --git a/third_party/libosmium/test/t/geom/test_tile.cpp b/third_party/libosmium/test/t/geom/test_tile.cpp
index ca289f76fc3..81a3d36ef28 100644
--- a/third_party/libosmium/test/t/geom/test_tile.cpp
+++ b/third_party/libosmium/test/t/geom/test_tile.cpp
@@ -1,10 +1,10 @@
 #include "catch.hpp"
 
-#include <sstream>
+#include "test_tile_data.hpp"
 
 #include <osmium/geom/tile.hpp>
 
-#include "test_tile_data.hpp"
+#include <sstream>
 
 TEST_CASE("Helper functions") {
     REQUIRE(osmium::geom::num_tiles_in_zoom(0) == 1);
@@ -41,7 +41,7 @@ TEST_CASE("Tile from x180.0 y90.0 at zoom 4") {
 
     osmium::geom::Tile t{4, l};
 
-    REQUIRE(t.x == (1 << 4) - 1);
+    REQUIRE(t.x == (1u << 4u) - 1);
     REQUIRE(t.y == 0);
     REQUIRE(t.z == 4);
     REQUIRE(t.valid());
@@ -52,7 +52,7 @@ TEST_CASE("Tile from x0.0 y0.0 at zoom 4") {
 
     osmium::geom::Tile t{4, l};
 
-    const auto n = 1 << (4-1);
+    const auto n = 1u << (4u - 1u);
     REQUIRE(t.x == n);
     REQUIRE(t.y == n);
     REQUIRE(t.z == 4);
@@ -65,7 +65,7 @@ TEST_CASE("Tile from max values at zoom 4") {
 }
 
 TEST_CASE("Tile from max values at zoom 30") {
-    osmium::geom::Tile t{30u, (1u<<30) - 1, (1u<<30) - 1};
+    osmium::geom::Tile t{30u, (1u << 30u) - 1, (1u << 30u) - 1};
     REQUIRE(t.valid());
 }
 
diff --git a/third_party/libosmium/test/t/geom/test_wkb.cpp b/third_party/libosmium/test/t/geom/test_wkb.cpp
index a4f2d99ec75..312595770fb 100644
--- a/third_party/libosmium/test/t/geom/test_wkb.cpp
+++ b/third_party/libosmium/test/t/geom/test_wkb.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
+#include "wnl_helper.hpp"
+
 #include <osmium/geom/mercator_projection.hpp>
 #include <osmium/geom/wkb.hpp>
 #include <osmium/util/endian.hpp>
 
-#include "wnl_helper.hpp"
-
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 
 TEST_CASE("WKB geometry factory (byte-order-dependant), points") {
diff --git a/third_party/libosmium/test/t/geom/test_wkt.cpp b/third_party/libosmium/test/t/geom/test_wkt.cpp
index 7f338680dc3..e22fbe00873 100644
--- a/third_party/libosmium/test/t/geom/test_wkt.cpp
+++ b/third_party/libosmium/test/t/geom/test_wkt.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
-#include <osmium/geom/mercator_projection.hpp>
-#include <osmium/geom/wkt.hpp>
-
 #include "area_helper.hpp"
 #include "wnl_helper.hpp"
 
+#include <osmium/geom/mercator_projection.hpp>
+#include <osmium/geom/wkt.hpp>
+
 TEST_CASE("WKT geometry for point") {
     const osmium::geom::WKTFactory<> factory;
     const std::string wkt{factory.create_point(osmium::Location{3.2, 4.2})};
@@ -60,6 +60,30 @@ TEST_CASE("WKT geometry factory") {
         }
     }
 
+    SECTION("polygon") {
+        const auto& wnl = create_test_wnl_closed(buffer);
+
+        SECTION("unique forwards (default)") {
+            const std::string wkt{factory.create_polygon(wnl)};
+            REQUIRE(wkt == "POLYGON((3 3,4.1 4.1,3.6 4.1,3.1 3.5,3 3))");
+        }
+
+        SECTION("unique backwards") {
+            const std::string wkt{factory.create_polygon(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward)};
+            REQUIRE(wkt == "POLYGON((3 3,3.1 3.5,3.6 4.1,4.1 4.1,3 3))");
+        }
+
+        SECTION("all forwards") {
+            const std::string wkt{factory.create_polygon(wnl,  osmium::geom::use_nodes::all)};
+            REQUIRE(wkt == "POLYGON((3 3,4.1 4.1,4.1 4.1,3.6 4.1,3.1 3.5,3 3))");
+        }
+
+        SECTION("all backwards") {
+            const std::string wkt{factory.create_polygon(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward)};
+            REQUIRE(wkt == "POLYGON((3 3,3.1 3.5,3.6 4.1,4.1 4.1,4.1 4.1,3 3))");
+        }
+    }
+
     SECTION("empty linestring") {
         const auto& wnl = create_test_wnl_empty(buffer);
 
diff --git a/third_party/libosmium/test/t/geom/wnl_helper.hpp b/third_party/libosmium/test/t/geom/wnl_helper.hpp
index 68de4c3ef9e..2f40dfdb968 100644
--- a/third_party/libosmium/test/t/geom/wnl_helper.hpp
+++ b/third_party/libosmium/test/t/geom/wnl_helper.hpp
@@ -16,6 +16,19 @@ inline const osmium::WayNodeList& create_test_wnl_okay(osmium::memory::Buffer& b
     return buffer.get<osmium::WayNodeList>(pos);
 }
 
+inline const osmium::WayNodeList& create_test_wnl_closed(osmium::memory::Buffer& buffer) {
+    const auto pos = osmium::builder::add_way_node_list(buffer, _nodes({
+        {1, {3.0, 3.0}},
+        {2, {4.1, 4.1}},
+        {3, {4.1, 4.1}},
+        {4, {3.6, 4.1}},
+        {5, {3.1, 3.5}},
+        {6, {3.0, 3.0}},
+    }));
+
+    return buffer.get<osmium::WayNodeList>(pos);
+}
+
 inline const osmium::WayNodeList& create_test_wnl_empty(osmium::memory::Buffer& buffer) {
     {
         osmium::builder::WayNodeListBuilder wnl_builder(buffer);
diff --git a/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp b/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp
index 7b20f129cf3..591e85a7bcb 100644
--- a/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp
+++ b/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp
@@ -1,7 +1,7 @@
 #include "catch.hpp"
 
-#include <osmium/dynamic_handler.hpp>
 #include <osmium/builder/attr.hpp>
+#include <osmium/dynamic_handler.hpp>
 #include <osmium/visitor.hpp>
 
 struct Handler1 : public osmium::handler::Handler {
@@ -12,23 +12,23 @@ struct Handler1 : public osmium::handler::Handler {
         count(c) {
     }
 
-    void node(const osmium::Node&) noexcept {
+    void node(const osmium::Node& /*node*/) noexcept {
         ++count;
     }
 
-    void way(const osmium::Way&) noexcept {
+    void way(const osmium::Way& /*way*/) noexcept {
         ++count;
     }
 
-    void relation(const osmium::Relation&) noexcept {
+    void relation(const osmium::Relation& /*relation*/) noexcept {
         ++count;
     }
 
-    void area(const osmium::Area&) noexcept {
+    void area(const osmium::Area& /*area*/) noexcept {
         ++count;
     }
 
-    void changeset(const osmium::Changeset&) noexcept {
+    void changeset(const osmium::Changeset& /*changeset*/) noexcept {
         ++count;
     }
 
@@ -46,30 +46,30 @@ struct Handler2 : public osmium::handler::Handler {
         count(c) {
     }
 
-    void node(const osmium::Node&) noexcept {
+    void node(const osmium::Node& /*node*/) noexcept {
         count += 2;
     }
 
-    void way(const osmium::Way&) noexcept {
+    void way(const osmium::Way& /*way*/) noexcept {
         count += 2;
     }
 
-    void relation(const osmium::Relation&) noexcept {
+    void relation(const osmium::Relation& /*relation*/) noexcept {
         count += 2;
     }
 
-    void area(const osmium::Area&) noexcept {
+    void area(const osmium::Area& /*area*/) noexcept {
         count += 2;
     }
 
-    void changeset(const osmium::Changeset&) noexcept {
+    void changeset(const osmium::Changeset& /*changeset*/) noexcept {
         count += 2;
     }
 
 };
 
 osmium::memory::Buffer fill_buffer() {
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
     osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_node(buffer, _id(1));
diff --git a/third_party/libosmium/test/t/index/test_file_based_index.cpp b/third_party/libosmium/test/t/index/test_file_based_index.cpp
index 278f43fa1bd..1489b825a22 100644
--- a/third_party/libosmium/test/t/index/test_file_based_index.cpp
+++ b/third_party/libosmium/test/t/index/test_file_based_index.cpp
@@ -1,155 +1,158 @@
-
 #include "catch.hpp"
 
-#include <osmium/osm/types.hpp>
-#include <osmium/osm/location.hpp>
 #include <osmium/index/detail/tmpfile.hpp>
-#include <osmium/util/file.hpp>
-
 #include <osmium/index/map/dense_file_array.hpp>
 #include <osmium/index/map/sparse_file_array.hpp>
-
 #include <osmium/index/node_locations_map.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/util/file.hpp>
 
-TEST_CASE("File based index") {
-
+TEST_CASE("File based dense index") {
     const int fd = osmium::detail::create_tmp_file();
 
-    REQUIRE(osmium::util::file_size(fd) == 0);
+    REQUIRE(osmium::file_size(fd) == 0);
 
     const osmium::unsigned_object_id_type id1 = 6;
     const osmium::unsigned_object_id_type id2 = 3;
-    const osmium::Location loc1(1.2, 4.5);
-    const osmium::Location loc2(3.5, -7.2);
+    const osmium::Location loc1{1.2, 4.5};
+    const osmium::Location loc2{3.5, -7.2};
 
-    SECTION("dense index") {
-        using index_type = osmium::index::map::DenseFileArray<osmium::unsigned_object_id_type, osmium::Location>;
-        constexpr const size_t S = sizeof(index_type::element_type);
+    using index_type = osmium::index::map::DenseFileArray<osmium::unsigned_object_id_type, osmium::Location>;
+    constexpr const size_t S = sizeof(index_type::element_type);
 
-        {
-            index_type index{fd};
+    {
+        index_type index{fd};
 
-            REQUIRE(index.size() == 0);
+        REQUIRE(index.size() == 0);
 
-            REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  3), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  6), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  3), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  6), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
 
-            index.set(id1, loc1);
-            REQUIRE(index.size() == 7);
+        index.set(id1, loc1);
+        REQUIRE(index.size() == 7);
 
-            index.set(id2, loc2);
-            REQUIRE(index.size() == 7);
+        index.set(id2, loc2);
+        REQUIRE(index.size() == 7);
 
-            index.sort();
+        index.sort();
 
-            REQUIRE(loc1 == index.get(id1));
-            REQUIRE(loc2 == index.get(id2));
+        REQUIRE(loc1 == index.get(id1));
+        REQUIRE(loc2 == index.get(id2));
 
-            REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
 
-            REQUIRE(index.size() == 7);
-            REQUIRE(std::distance(index.cbegin(), index.cend()) == 7);
+        REQUIRE(index.size() == 7);
+        REQUIRE(std::distance(index.cbegin(), index.cend()) == 7);
 
-            REQUIRE(osmium::util::file_size(fd) >= (6 * S));
-        }
-
-        {
-            index_type index{fd};
-            REQUIRE(osmium::util::file_size(fd) >= (6 * S));
-
-            REQUIRE(index.size() == 7);
+        REQUIRE(osmium::file_size(fd) >= (6 * S));
+    }
 
-            REQUIRE(loc1 == index.get(id1));
-            REQUIRE(loc2 == index.get(id2));
+    {
+        index_type index{fd};
+        REQUIRE(osmium::file_size(fd) >= (6 * S));
+
+        REQUIRE(index.size() == 7);
+
+        REQUIRE(loc1 == index.get(id1));
+        REQUIRE(loc2 == index.get(id2));
+
+        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+
+        REQUIRE(index.size() == 7);
+        REQUIRE(std::distance(index.cbegin(), index.cend()) == 7);
+
+        auto it = index.cbegin();
+        REQUIRE(*it++ == osmium::Location{});
+        REQUIRE(*it++ == osmium::Location{});
+        REQUIRE(*it++ == osmium::Location{});
+        REQUIRE(*it++ == loc2);
+        REQUIRE(*it++ == osmium::Location{});
+        REQUIRE(*it++ == osmium::Location{});
+        REQUIRE(*it++ == loc1);
+        REQUIRE(it++ == index.cend());
+    }
+}
 
-            REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+TEST_CASE("File based sparse index") {
+    const int fd = osmium::detail::create_tmp_file();
 
-            REQUIRE(index.size() == 7);
-            REQUIRE(std::distance(index.cbegin(), index.cend()) == 7);
+    REQUIRE(osmium::file_size(fd) == 0);
 
-            auto it = index.cbegin();
-            REQUIRE(*it++ == osmium::Location{});
-            REQUIRE(*it++ == osmium::Location{});
-            REQUIRE(*it++ == osmium::Location{});
-            REQUIRE(*it++ == loc2);
-            REQUIRE(*it++ == osmium::Location{});
-            REQUIRE(*it++ == osmium::Location{});
-            REQUIRE(*it++ == loc1);
-            REQUIRE(it++ == index.cend());
-        }
-    }
+    const osmium::unsigned_object_id_type id1 = 6;
+    const osmium::unsigned_object_id_type id2 = 3;
+    const osmium::Location loc1{1.2, 4.5};
+    const osmium::Location loc2{3.5, -7.2};
 
-    SECTION("sparse index") {
-        using index_type = osmium::index::map::SparseFileArray<osmium::unsigned_object_id_type, osmium::Location>;
-        constexpr const size_t S = sizeof(index_type::element_type);
+    using index_type = osmium::index::map::SparseFileArray<osmium::unsigned_object_id_type, osmium::Location>;
+    constexpr const size_t S = sizeof(index_type::element_type);
 
-        {
-            index_type index{fd};
+    {
+        index_type index{fd};
 
-            REQUIRE(index.size() == 0);
+        REQUIRE(index.size() == 0);
 
-            REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  3), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  6), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  3), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  6), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
 
-            index.set(id1, loc1);
-            REQUIRE(index.size() == 1);
+        index.set(id1, loc1);
+        REQUIRE(index.size() == 1);
 
-            index.set(id2, loc2);
-            REQUIRE(index.size() == 2);
+        index.set(id2, loc2);
+        REQUIRE(index.size() == 2);
 
-            index.sort();
+        index.sort();
 
-            REQUIRE(loc1 == index.get(id1));
-            REQUIRE(loc2 == index.get(id2));
+        REQUIRE(loc1 == index.get(id1));
+        REQUIRE(loc2 == index.get(id2));
 
-            REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
 
-            REQUIRE(index.size() == 2);
-            REQUIRE(std::distance(index.cbegin(), index.cend()) == 2);
+        REQUIRE(index.size() == 2);
+        REQUIRE(std::distance(index.cbegin(), index.cend()) == 2);
 
-            REQUIRE(osmium::util::file_size(fd) >= (2 * S));
-        }
+        REQUIRE(osmium::file_size(fd) >= (2 * S));
+    }
 
-        {
-            index_type index{fd};
-            REQUIRE(osmium::util::file_size(fd) >= (2 * S));
+    {
+        index_type index{fd};
+        REQUIRE(osmium::file_size(fd) >= (2 * S));
 
-            REQUIRE(index.size() == 2);
+        REQUIRE(index.size() == 2);
 
-            REQUIRE(loc1 == index.get(id1));
-            REQUIRE(loc2 == index.get(id2));
+        REQUIRE(loc1 == index.get(id1));
+        REQUIRE(loc2 == index.get(id2));
 
-            REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-            REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
 
-            REQUIRE(index.size() == 2);
-            REQUIRE(std::distance(index.cbegin(), index.cend()) == 2);
-        }
+        REQUIRE(index.size() == 2);
+        REQUIRE(std::distance(index.cbegin(), index.cend()) == 2);
     }
 }
 
diff --git a/third_party/libosmium/test/t/index/test_id_set.cpp b/third_party/libosmium/test/t/index/test_id_set.cpp
index ec8280a386a..33d9325a9e7 100644
--- a/third_party/libosmium/test/t/index/test_id_set.cpp
+++ b/third_party/libosmium/test/t/index/test_id_set.cpp
@@ -1,4 +1,3 @@
-
 #include "catch.hpp"
 
 #include <osmium/index/id_set.hpp>
@@ -10,7 +9,7 @@ TEST_CASE("Basic functionality of IdSetDense") {
     REQUIRE_FALSE(s.get(17));
     REQUIRE_FALSE(s.get(28));
     REQUIRE(s.empty());
-    REQUIRE(s.size() == 0);
+    REQUIRE(s.size() == 0); // NOLINT(readability-container-size-empty)
 
     s.set(17);
     REQUIRE(s.get(17));
@@ -42,7 +41,6 @@ TEST_CASE("Basic functionality of IdSetDense") {
 
     s.clear();
     REQUIRE(s.empty());
-    REQUIRE(s.size() == 0);
 }
 
 TEST_CASE("Iterating over IdSetDense") {
@@ -51,9 +49,9 @@ TEST_CASE("Iterating over IdSetDense") {
     s.set(35);
     s.set(35);
     s.set(20);
-    s.set(1ULL << 33);
+    s.set(1ull << 33u);
     s.set(21);
-    s.set((1ULL << 27) + 13);
+    s.set((1ull << 27u) + 13u);
 
     REQUIRE(s.size() == 6);
 
@@ -71,10 +69,10 @@ TEST_CASE("Iterating over IdSetDense") {
     REQUIRE(*it == 35);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == (1ULL << 27) + 13);
+    REQUIRE(*it == (1ull << 27u) + 13u);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == 1ULL << 33);
+    REQUIRE(*it == 1ull << 33u);
     ++it;
     REQUIRE(it == s.end());
 }
@@ -100,10 +98,10 @@ TEST_CASE("Large gap") {
     osmium::index::IdSetDense<osmium::unsigned_object_id_type> s;
 
     s.set(3);
-    s.set(1 << 30);
+    s.set(1u << 30u);
 
-    REQUIRE(s.get(1 << 30));
-    REQUIRE_FALSE(s.get(1 << 29));
+    REQUIRE(s.get(1u << 30u));
+    REQUIRE_FALSE(s.get(1u << 29u));
 }
 
 TEST_CASE("Basic functionality of IdSetSmall") {
@@ -133,9 +131,9 @@ TEST_CASE("Iterating over IdSetSmall") {
     s.set(35);
     s.set(35);
     s.set(20);
-    s.set(1ULL << 33);
+    s.set(1ull << 33u);
     s.set(21);
-    s.set((1ULL << 27) + 13);
+    s.set((1ull << 27u) + 13u);
 
     // needs to be called before size() and iterator will work properly
     s.sort_unique();
@@ -156,10 +154,10 @@ TEST_CASE("Iterating over IdSetSmall") {
     REQUIRE(*it == 35);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == (1ULL << 27) + 13);
+    REQUIRE(*it == (1ull << 27u) + 13u);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == 1ULL << 33);
+    REQUIRE(*it == 1ull << 33u);
     ++it;
     REQUIRE(it == s.end());
 }
diff --git a/third_party/libosmium/test/t/index/test_id_to_location.cpp b/third_party/libosmium/test/t/index/test_id_to_location.cpp
index 4b633141737..f3416d556c2 100644
--- a/third_party/libosmium/test/t/index/test_id_to_location.cpp
+++ b/third_party/libosmium/test/t/index/test_id_to_location.cpp
@@ -1,8 +1,5 @@
 #include "catch.hpp"
 
-#include <osmium/osm/types.hpp>
-#include <osmium/osm/location.hpp>
-
 #include <osmium/index/map/dense_file_array.hpp>
 #include <osmium/index/map/dense_mem_array.hpp>
 #include <osmium/index/map/dense_mmap_array.hpp>
@@ -13,8 +10,9 @@
 #include <osmium/index/map/sparse_mem_map.hpp>
 #include <osmium/index/map/sparse_mem_table.hpp>
 #include <osmium/index/map/sparse_mmap_array.hpp>
-
 #include <osmium/index/node_locations_map.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
 
 static_assert(osmium::index::empty_value<osmium::Location>() == osmium::Location{}, "Empty value for location is wrong");
 
diff --git a/third_party/libosmium/test/t/index/test_object_pointer_collection.cpp b/third_party/libosmium/test/t/index/test_object_pointer_collection.cpp
index cd5ae73a98f..36fe154da59 100644
--- a/third_party/libosmium/test/t/index/test_object_pointer_collection.cpp
+++ b/third_party/libosmium/test/t/index/test_object_pointer_collection.cpp
@@ -1,4 +1,3 @@
-
 #include "catch.hpp"
 
 #include <osmium/builder/attr.hpp>
@@ -7,7 +6,7 @@
 #include <osmium/osm/object_comparisons.hpp>
 #include <osmium/visitor.hpp>
 
-using namespace osmium::builder::attr;
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Create ObjectPointerCollection") {
     osmium::memory::Buffer buffer{1024, osmium::memory::Buffer::auto_grow::yes};
@@ -29,7 +28,7 @@ TEST_CASE("Create ObjectPointerCollection") {
 
     osmium::ObjectPointerCollection collection;
     REQUIRE(collection.empty());
-    REQUIRE(collection.size() == 0);
+    REQUIRE(collection.size() == 0); // NOLINT(readability-container-size-empty)
 
     osmium::apply(buffer, collection);
 
@@ -81,6 +80,5 @@ TEST_CASE("Create ObjectPointerCollection") {
     collection.clear();
 
     REQUIRE(collection.empty());
-    REQUIRE(collection.size() == 0);
 }
 
diff --git a/third_party/libosmium/test/t/index/test_relations_map.cpp b/third_party/libosmium/test/t/index/test_relations_map.cpp
index 1d77af28626..8eac92624ae 100644
--- a/third_party/libosmium/test/t/index/test_relations_map.cpp
+++ b/third_party/libosmium/test/t/index/test_relations_map.cpp
@@ -1,20 +1,19 @@
-
 #include "catch.hpp"
 
-#include <type_traits>
-
 #include <osmium/index/relations_map.hpp>
 
-static_assert(std::is_default_constructible<osmium::index::RelationsMapIndex>::value == false, "RelationsMapIndex should not be default constructible");
-static_assert(std::is_copy_constructible<osmium::index::RelationsMapIndex>::value == false, "RelationsMapIndex should not be copy constructible");
-static_assert(std::is_copy_constructible<osmium::index::RelationsMapStash>::value == false, "RelationsMapStash should not be copy constructible");
-static_assert(std::is_copy_assignable<osmium::index::RelationsMapIndex>::value == false, "RelationsMapIndex should not be copy assignable");
-static_assert(std::is_copy_assignable<osmium::index::RelationsMapStash>::value == false, "RelationsMapStash should not be copy assignable");
+#include <type_traits>
+
+static_assert(!std::is_default_constructible<osmium::index::RelationsMapIndex>::value, "RelationsMapIndex should not be default constructible");
+static_assert(!std::is_copy_constructible<osmium::index::RelationsMapIndex>::value, "RelationsMapIndex should not be copy constructible");
+static_assert(!std::is_copy_constructible<osmium::index::RelationsMapStash>::value, "RelationsMapStash should not be copy constructible");
+static_assert(!std::is_copy_assignable<osmium::index::RelationsMapIndex>::value, "RelationsMapIndex should not be copy assignable");
+static_assert(!std::is_copy_assignable<osmium::index::RelationsMapStash>::value, "RelationsMapStash should not be copy assignable");
 
 TEST_CASE("RelationsMapStash lvalue") {
     osmium::index::RelationsMapStash stash;
     REQUIRE(stash.empty());
-    REQUIRE(stash.size() == 0);
+    REQUIRE(stash.size() == 0); // NOLINT(readability-container-size-empty)
 
     stash.add(1, 2);
     stash.add(2, 3);
@@ -57,7 +56,6 @@ TEST_CASE("RelationsMapStash rvalue") {
 TEST_CASE("RelationsMapStash reverse index") {
     osmium::index::RelationsMapStash stash;
     REQUIRE(stash.empty());
-    REQUIRE(stash.size() == 0);
 
     stash.add(1, 2);
     stash.add(2, 3);
@@ -84,7 +82,6 @@ TEST_CASE("RelationsMapStash reverse index") {
 TEST_CASE("RelationsMapStash both indexes") {
     osmium::index::RelationsMapStash stash;
     REQUIRE(stash.empty());
-    REQUIRE(stash.size() == 0);
 
     stash.add(1, 2);
     stash.add(2, 3);
diff --git a/third_party/libosmium/test/t/io/data_pbf_version-1-densenodes.osm.pbf b/third_party/libosmium/test/t/io/data_pbf_version-1-densenodes.osm.pbf
new file mode 100644
index 00000000000..6d3b0a8f1ee
Binary files /dev/null and b/third_party/libosmium/test/t/io/data_pbf_version-1-densenodes.osm.pbf differ
diff --git a/third_party/libosmium/test/t/io/data_pbf_version-1.osm b/third_party/libosmium/test/t/io/data_pbf_version-1.osm
new file mode 100644
index 00000000000..f731ac584cf
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data_pbf_version-1.osm
@@ -0,0 +1,4 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6" generator="osmium/1.7.1">
+  <node id="2" lat="50" lon="10.01"/>
+</osm>
diff --git a/third_party/libosmium/test/t/io/data_pbf_version-1.osm.pbf b/third_party/libosmium/test/t/io/data_pbf_version-1.osm.pbf
new file mode 100644
index 00000000000..3766b8c0ca9
Binary files /dev/null and b/third_party/libosmium/test/t/io/data_pbf_version-1.osm.pbf differ
diff --git a/third_party/libosmium/test/t/io/test_bzip2.cpp b/third_party/libosmium/test/t/io/test_bzip2.cpp
index 3e3fe81829e..256d012dba1 100644
--- a/third_party/libosmium/test/t/io/test_bzip2.cpp
+++ b/third_party/libosmium/test/t/io/test_bzip2.cpp
@@ -1,12 +1,13 @@
 #include "catch.hpp"
-#include "utils.hpp"
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
+#include "utils.hpp"
 
 #include <osmium/io/bzip2_compression.hpp>
 
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
 TEST_CASE("Read bzip2-compressed file") {
     const std::string input_file = with_data_dir("t/io/data_bzip2.txt.bz2");
 
diff --git a/third_party/libosmium/test/t/io/test_compression_factory.cpp b/third_party/libosmium/test/t/io/test_compression_factory.cpp
index 97cb1535d8e..9bfd4a52e96 100644
--- a/third_party/libosmium/test/t/io/test_compression_factory.cpp
+++ b/third_party/libosmium/test/t/io/test_compression_factory.cpp
@@ -1,4 +1,3 @@
-
 #include "catch.hpp"
 
 #include <osmium/io/compression.hpp>
diff --git a/third_party/libosmium/test/t/io/test_file_formats.cpp b/third_party/libosmium/test/t/io/test_file_formats.cpp
index 284d4777913..fc2517ac6ba 100644
--- a/third_party/libosmium/test/t/io/test_file_formats.cpp
+++ b/third_party/libosmium/test/t/io/test_file_formats.cpp
@@ -1,14 +1,14 @@
 #include "catch.hpp"
 
-#include <iterator>
-
 #include <osmium/io/file.hpp>
 
+#include <iterator>
+
 TEST_CASE("Default file format") {
     const osmium::io::File f;
     REQUIRE(osmium::io::file_format::unknown == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
 }
 
@@ -16,7 +16,7 @@ TEST_CASE("File format when empty (stdin/stdout)") {
     const osmium::io::File f{""};
     REQUIRE(osmium::io::file_format::unknown == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
 }
 
@@ -24,16 +24,16 @@ TEST_CASE("File format from dash (stdin/stdout)") {
     const osmium::io::File f{"-"};
     REQUIRE(osmium::io::file_format::unknown == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
 }
 
 TEST_CASE("File format from dash with osm.bz2") {
     const osmium::io::File f{"-", "osm.bz2"};
-    REQUIRE("" == f.filename());
+    REQUIRE(f.filename().empty());
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::bzip2 == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -41,7 +41,7 @@ TEST_CASE("Detect file format by suffix 'osm'") {
     const osmium::io::File f{"test.osm"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -49,7 +49,7 @@ TEST_CASE("Detect file format by suffix 'pbf'") {
     const osmium::io::File f{"test.pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -57,7 +57,7 @@ TEST_CASE("Detect file format by suffix 'osm.pbf'") {
     const osmium::io::File f{"test.osm.pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -65,7 +65,7 @@ TEST_CASE("Detect file format by suffix 'opl'") {
     const osmium::io::File f{"test.opl"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -73,7 +73,7 @@ TEST_CASE("Detect file format by suffix 'osm.opl'") {
     const osmium::io::File f{"test.osm.opl"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -81,7 +81,7 @@ TEST_CASE("Detect file format by suffix 'osm.gz'") {
     const osmium::io::File f{"test.osm.gz"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::gzip == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -89,7 +89,7 @@ TEST_CASE("Detect file format by suffix 'opl.bz2'") {
     const osmium::io::File f{"test.osm.opl.bz2"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::bzip2 == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -97,7 +97,7 @@ TEST_CASE("Detect file format by suffix 'osc.gz'") {
     const osmium::io::File f{"test.osc.gz"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::gzip == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -105,7 +105,7 @@ TEST_CASE("Detect file format by suffix 'opl.gz'") {
     const osmium::io::File f{"test.osh.opl.gz"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::gzip == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -113,7 +113,7 @@ TEST_CASE("Detect file format by suffix 'osh.pbf'") {
     const osmium::io::File f{"test.osh.pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -121,7 +121,7 @@ TEST_CASE("Override file format by suffix 'osm'") {
     const osmium::io::File f{"test", "osm"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -129,7 +129,7 @@ TEST_CASE("Override file format by suffix 'pbf'") {
     const osmium::io::File f{"test", "pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -137,7 +137,7 @@ TEST_CASE("Override file format by suffix 'osm.pbf'") {
     const osmium::io::File f{"test", "osm.pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -145,7 +145,7 @@ TEST_CASE("Override file format by suffix 'opl'") {
     const osmium::io::File f{"test", "opl"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -153,7 +153,7 @@ TEST_CASE("Override file format by suffix 'osm.opl'") {
     const osmium::io::File f{"test", "osm.opl"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -161,7 +161,7 @@ TEST_CASE("Override file format by suffix 'osm.gz'") {
     const osmium::io::File f{"test", "osm.gz"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::gzip == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -169,7 +169,7 @@ TEST_CASE("Override file format by suffix 'osm.opl.bz2'") {
     const osmium::io::File f{"test", "osm.opl.bz2"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::bzip2 == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -177,7 +177,7 @@ TEST_CASE("Override file format by suffix 'osc.gz'") {
     const osmium::io::File f{"test", "osc.gz"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::gzip == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -185,7 +185,7 @@ TEST_CASE("Override file format by suffix 'osh.opl.gz'") {
     const osmium::io::File f{"test", "osh.opl.gz"};
     REQUIRE(osmium::io::file_format::opl == f.format());
     REQUIRE(osmium::io::file_compression::gzip == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -193,7 +193,7 @@ TEST_CASE("File format by suffix 'blackhole'") {
     const osmium::io::File f{"test.blackhole"};
     REQUIRE(osmium::io::file_format::blackhole == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -201,7 +201,7 @@ TEST_CASE("Override file format by suffix 'blackhole'") {
     const osmium::io::File f{"test", "blackhole"};
     REQUIRE(osmium::io::file_format::blackhole == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -209,7 +209,7 @@ TEST_CASE("Override file format by suffix 'osm.blackhole'") {
     const osmium::io::File f{"test", "osm.blackhole"};
     REQUIRE(osmium::io::file_format::blackhole == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -217,7 +217,7 @@ TEST_CASE("Override file format by suffix 'osm.blackhole.bz2'") {
     const osmium::io::File f{"test", "osm.blackhole.bz2"};
     REQUIRE(osmium::io::file_format::blackhole == f.format());
     REQUIRE(osmium::io::file_compression::bzip2 == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -225,7 +225,7 @@ TEST_CASE("Override file format by suffix 'osh.blackhole.gz'") {
     const osmium::io::File f{"test", "osh.blackhole.gz"};
     REQUIRE(osmium::io::file_format::blackhole == f.format());
     REQUIRE(osmium::io::file_compression::gzip == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -233,7 +233,7 @@ TEST_CASE("Override file format by suffix 'osh.pbf'") {
     const osmium::io::File f{"test", "osh.pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -241,7 +241,7 @@ TEST_CASE("Format option pbf history") {
     const osmium::io::File f{"test", "pbf,history=true"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -289,7 +289,7 @@ TEST_CASE("URL without format") {
     const osmium::io::File f{"http://www.example.com/api"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -297,7 +297,7 @@ TEST_CASE("URL without format and filename") {
     const osmium::io::File f{"http://planet.osm.org/pbf/planet-latest.osm.pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(false == f.has_multiple_object_versions());
+    REQUIRE_FALSE(f.has_multiple_object_versions());
     f.check();
 }
 
@@ -305,7 +305,7 @@ TEST_CASE("URL with format") {
     const osmium::io::File f{"http://www.example.com/api", "osh"};
     REQUIRE(osmium::io::file_format::xml == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE(true == f.has_multiple_object_versions());
+    REQUIRE(f.has_multiple_object_versions());
     f.check();
 }
 
diff --git a/third_party/libosmium/test/t/io/test_opl_parser.cpp b/third_party/libosmium/test/t/io/test_opl_parser.cpp
index 88cd570263c..5d13bb12dfe 100644
--- a/third_party/libosmium/test/t/io/test_opl_parser.cpp
+++ b/third_party/libosmium/test/t/io/test_opl_parser.cpp
@@ -1,14 +1,14 @@
-
-#include <algorithm>
-#include <cstring>
-
 #include "catch.hpp"
+
 #include "utils.hpp"
 
 #include <osmium/io/detail/opl_input_format.hpp>
 #include <osmium/io/opl_input.hpp>
 #include <osmium/opl.hpp>
 
+#include <algorithm>
+#include <cstring>
+
 namespace oid = osmium::io::detail;
 
 TEST_CASE("Parse OPL: base exception") {
@@ -161,8 +161,7 @@ TEST_CASE("Parse OPL: parse string") {
         const char* s = "";
         const char* e = s + std::strlen(s);
         oid::opl_parse_string(&s, result);
-        REQUIRE(result.size() == 0);
-        REQUIRE(result == "");
+        REQUIRE(result.empty());
         REQUIRE(s == e);
     }
 
@@ -384,8 +383,8 @@ TEST_CASE("Parse OPL: tags") {
         oid::opl_parse_tags(data, buffer);
         const auto& taglist = buffer.get<osmium::TagList>(0);
         REQUIRE(taglist.size() == 1);
-        REQUIRE(std::string{taglist.begin()->key()} == "");
-        REQUIRE(std::string{taglist.begin()->value()} == "");
+        REQUIRE(std::string{taglist.begin()->key()}.empty());
+        REQUIRE(std::string{taglist.begin()->value()}.empty());
     }
 
     SECTION("Multiple tags") {
@@ -548,7 +547,7 @@ TEST_CASE("Parse OPL: members") {
         auto it = rml.begin();
         REQUIRE(it->type() == osmium::item_type::node);
         REQUIRE(it->ref() == 123);
-        REQUIRE(std::string{it->role()} == "");
+        REQUIRE(std::string{it->role()}.empty());
         ++it;
         REQUIRE(it == rml.end());
     }
@@ -562,7 +561,7 @@ TEST_CASE("Parse OPL: members") {
         auto it = rml.begin();
         REQUIRE(it->type() == osmium::item_type::node);
         REQUIRE(it->ref() == 123);
-        REQUIRE(std::string{it->role()} == "");
+        REQUIRE(std::string{it->role()}.empty());
         ++it;
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 456);
@@ -584,7 +583,7 @@ TEST_CASE("Parse OPL: members") {
         auto it = rml.begin();
         REQUIRE(it->type() == osmium::item_type::node);
         REQUIRE(it->ref() == 123);
-        REQUIRE(std::string{it->role()} == "");
+        REQUIRE(std::string{it->role()}.empty());
         ++it;
         REQUIRE(it->type() == osmium::item_type::way);
         REQUIRE(it->ref() == 456);
diff --git a/third_party/libosmium/test/t/io/test_output_iterator.cpp b/third_party/libosmium/test/t/io/test_output_iterator.cpp
index df032a8fc0e..23b117dc573 100644
--- a/third_party/libosmium/test/t/io/test_output_iterator.cpp
+++ b/third_party/libosmium/test/t/io/test_output_iterator.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
-#include <osmium/io/xml_output.hpp>
 #include <osmium/io/output_iterator.hpp>
 #include <osmium/io/writer.hpp>
+#include <osmium/io/xml_output.hpp>
 
 TEST_CASE("Output iterator should be copy constructable") {
-    const osmium::io::Header header;
+    const osmium::io::Header header{};
     osmium::io::Writer writer{"test.osm", header, osmium::io::overwrite::allow};
 
     osmium::io::OutputIterator<osmium::io::Writer> out1{writer};
@@ -13,7 +13,7 @@ TEST_CASE("Output iterator should be copy constructable") {
 }
 
 TEST_CASE("Output iterator should be copy assignable") {
-    const osmium::io::Header header;
+    const osmium::io::Header header{};
     osmium::io::Writer writer1{"test1.osm", header, osmium::io::overwrite::allow};
     osmium::io::Writer writer2{"test2.osm", header, osmium::io::overwrite::allow};
 
@@ -24,7 +24,7 @@ TEST_CASE("Output iterator should be copy assignable") {
 }
 
 TEST_CASE("Output iterator should be incrementable") {
-    const osmium::io::Header header;
+    const osmium::io::Header header{};
     osmium::io::Writer writer{"test.osm", header, osmium::io::overwrite::allow};
     osmium::io::OutputIterator<osmium::io::Writer> out{writer};
 
diff --git a/third_party/libosmium/test/t/io/test_output_utils.cpp b/third_party/libosmium/test/t/io/test_output_utils.cpp
index a760683483e..5c4b187338d 100644
--- a/third_party/libosmium/test/t/io/test_output_utils.cpp
+++ b/third_party/libosmium/test/t/io/test_output_utils.cpp
@@ -1,10 +1,9 @@
-
 #include "catch.hpp"
 
-#include <locale>
-
 #include <osmium/io/detail/string_util.hpp>
 
+#include <locale>
+
 TEST_CASE("output formatted") {
 
     std::string out;
diff --git a/third_party/libosmium/test/t/io/test_pbf.cpp b/third_party/libosmium/test/t/io/test_pbf.cpp
new file mode 100644
index 00000000000..bfa9e9c3ab0
--- /dev/null
+++ b/third_party/libosmium/test/t/io/test_pbf.cpp
@@ -0,0 +1,45 @@
+#include "catch.hpp"
+
+#include "utils.hpp"
+
+#include <osmium/io/pbf_input.hpp>
+#include <osmium/io/reader.hpp>
+#include <osmium/osm/object.hpp>
+
+/**
+ * Osmosis writes PBF with changeset=-1 if its input file did not contain the changeset field.
+ * The default value of the version field is -1 in the OSM.PBF format.
+ *
+ * t/io/data_pbf_version-1.osm.pbf was created using the following steps:
+ *
+ * * Convert t/io/data_pbf_version-1.osm to PBF format using Osmium Tool:
+ *   `osmium cat -o tmp.osm.pbf --output-format pbf,add_metadata=no /data_pbf_version-1.osm.pbf`)
+ * * Convert that file using Osmosis:
+ *   `osmosis --read-pbf file=tmp.osm.pbf --write-pbf file=data_pbf_version-1.osm.pbf compress=none usedense=false`
+ */
+TEST_CASE("Read PBF file with version=-1 and changeset=-1 (written by Osmosis)") {
+    osmium::memory::Buffer buffer = osmium::io::read_file(with_data_dir("t/io/data_pbf_version-1.osm.pbf"));
+    // one node should be in this buffer
+    const osmium::OSMObject& object = *(buffer.cbegin<osmium::OSMObject>());
+    REQUIRE(object.version() == 0);
+    REQUIRE(object.changeset() == 0);
+}
+
+/**
+ * Osmosis writes PBF with changeset=-1 if its input file did not contain the changeset field.
+ * The default value of the version field is -1 in the OSM.PBF format.
+ *
+ * t/io/data_pbf_version-1.osm.pbf was created using the following steps:
+ *
+ * * Convert t/io/data_pbf_version-1.osm to PBF format using Osmium Tool:
+ *   `osmium cat -o tmp.osm.pbf --output-format pbf,add_metadata=no /data_pbf_version-1.osm.pbf`)
+ * * Convert that file using Osmosis:
+ *   `osmosis --read-pbf file=tmp.osm.pbf --write-pbf file=data_pbf_version-1-densenodes.osm.pbf compress=none usedense=true`
+ */
+TEST_CASE("Read PBF file with version=-1 and changeset=-1 and DenseNodes (written by Osmosis)") {
+    osmium::memory::Buffer buffer = osmium::io::read_file(with_data_dir("t/io/data_pbf_version-1-densenodes.osm.pbf"));
+    // one node should be in this buffer
+    const osmium::OSMObject& object = *(buffer.cbegin<osmium::OSMObject>());
+    REQUIRE(object.version() == 0);
+    REQUIRE(object.changeset() == 0);
+}
diff --git a/third_party/libosmium/test/t/io/test_reader.cpp b/third_party/libosmium/test/t/io/test_reader.cpp
index 10cc3b10556..d528379cf8f 100644
--- a/third_party/libosmium/test/t/io/test_reader.cpp
+++ b/third_party/libosmium/test/t/io/test_reader.cpp
@@ -1,18 +1,19 @@
 #include "catch.hpp"
+
 #include "utils.hpp"
 
 #include <osmium/handler.hpp>
 #include <osmium/io/any_compression.hpp>
-#include <osmium/io/xml_input.hpp>
 #include <osmium/io/pbf_input.hpp>
-#include <osmium/visitor.hpp>
+#include <osmium/io/xml_input.hpp>
 #include <osmium/memory/buffer.hpp>
+#include <osmium/visitor.hpp>
 
 struct CountHandler : public osmium::handler::Handler {
 
     int count = 0;
 
-    void node(const osmium::Node&) {
+    void node(const osmium::Node& /*node*/) {
         ++count;
     }
 
diff --git a/third_party/libosmium/test/t/io/test_reader_fileformat.cpp b/third_party/libosmium/test/t/io/test_reader_fileformat.cpp
index 83b4a0d957d..7a2ae5bced5 100644
--- a/third_party/libosmium/test/t/io/test_reader_fileformat.cpp
+++ b/third_party/libosmium/test/t/io/test_reader_fileformat.cpp
@@ -1,5 +1,5 @@
-
 #include "catch.hpp"
+
 #include "utils.hpp"
 
 #include <osmium/io/reader.hpp>
diff --git a/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp b/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp
index 58333296677..c7bef89a3d8 100644
--- a/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp
+++ b/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp
@@ -1,12 +1,13 @@
-
 #include "catch.hpp"
-#include "utils.hpp"
 
-#include <string>
+#include "utils.hpp"
 
 #include <osmium/io/compression.hpp>
 #include <osmium/io/xml_input.hpp>
 
+#include <string>
+#include <utility>
+
 // The MockDecompressor behaves like other Decompressor classes, but "invents"
 // OSM data in XML format that can be read. Through a parameter to the
 // constructor it can be instructed to throw an exception in specific parts
@@ -19,14 +20,19 @@ class MockDecompressor : public osmium::io::Decompressor {
 
 public:
 
-    explicit MockDecompressor(const std::string& fail_in) :
-        Decompressor(),
-        m_fail_in(fail_in) {
+    explicit MockDecompressor(std::string fail_in) :
+        m_fail_in(std::move(fail_in)) {
         if (m_fail_in == "constructor") {
             throw std::runtime_error{"error constructor"};
         }
     }
 
+    MockDecompressor(const MockDecompressor&) = delete;
+    MockDecompressor& operator=(const MockDecompressor&) = delete;
+
+    MockDecompressor(MockDecompressor&&) = delete;
+    MockDecompressor& operator=(MockDecompressor&&) = delete;
+
     ~MockDecompressor() noexcept final = default;
 
     void add_node(std::string& s, int i) {
@@ -42,19 +48,17 @@ class MockDecompressor : public osmium::io::Decompressor {
         if (m_read_count == 1) {
             if (m_fail_in == "first read") {
                 throw std::runtime_error{"error first read"};
-            } else {
-                buffer += "<?xml version='1.0' encoding='UTF-8'?>\n<osm version='0.6' generator='testdata'>\n";
-                for (int i = 0; i < 1000; ++i) {
-                    add_node(buffer, i);
-                }
+            }
+            buffer += "<?xml version='1.0' encoding='UTF-8'?>\n<osm version='0.6' generator='testdata'>\n";
+            for (int i = 0; i < 1000; ++i) {
+                add_node(buffer, i);
             }
         } else if (m_read_count == 2) {
             if (m_fail_in == "second read") {
                 throw std::runtime_error{"error second read"};
-            } else {
-                for (int i = 1000; i < 2000; ++i) {
-                    add_node(buffer, i);
-                }
+            }
+            for (int i = 1000; i < 2000; ++i) {
+                add_node(buffer, i);
             }
         } else if (m_read_count == 3) {
             buffer += "</osm>";
diff --git a/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp b/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp
index f0aef07e1d4..65a421f9dff 100644
--- a/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp
+++ b/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp
@@ -1,8 +1,6 @@
-
 #include "catch.hpp"
-#include "utils.hpp"
 
-#include <string>
+#include "utils.hpp"
 
 #include <osmium/builder/attr.hpp>
 #include <osmium/builder/osm_object_builder.hpp>
@@ -15,6 +13,9 @@
 #include <osmium/thread/queue.hpp>
 #include <osmium/thread/util.hpp>
 
+#include <string>
+#include <utility>
+
 class MockParser : public osmium::io::detail::Parser {
 
     std::string m_fail_in;
@@ -22,9 +23,9 @@ class MockParser : public osmium::io::detail::Parser {
 public:
 
     MockParser(osmium::io::detail::parser_arguments& args,
-               const std::string& fail_in) :
+               std::string fail_in) :
         Parser(args),
-        m_fail_in(fail_in) {
+        m_fail_in(std::move(fail_in)) {
     }
 
     void run() final {
diff --git a/third_party/libosmium/test/t/io/test_string_table.cpp b/third_party/libosmium/test/t/io/test_string_table.cpp
index 6b7ccba9ac1..aefc11cb8d6 100644
--- a/third_party/libosmium/test/t/io/test_string_table.cpp
+++ b/third_party/libosmium/test/t/io/test_string_table.cpp
@@ -1,6 +1,7 @@
 #include "catch.hpp"
 
 #include <osmium/io/detail/string_table.hpp>
+#include <osmium/util/misc.hpp>
 
 TEST_CASE("Empty StringStore") {
     const osmium::io::detail::StringStore ss{100};
@@ -14,11 +15,11 @@ TEST_CASE("Add zero-length string to StringStore") {
     osmium::io::detail::StringStore ss{100};
 
     const char* s1 = ss.add("");
-    REQUIRE(std::string(s1) == "");
+    REQUIRE(std::string{s1}.empty());
 
     auto it = ss.begin();
     REQUIRE(s1 == *it);
-    REQUIRE(std::string(*it) == "");
+    REQUIRE(std::string{*it}.empty());
     REQUIRE(++it == ss.end());
 
     REQUIRE(ss.get_chunk_count() == 1);
@@ -30,8 +31,8 @@ TEST_CASE("Add strings to StringStore") {
     const char* s1 = ss.add("foo");
     const char* s2 = ss.add("bar");
     REQUIRE(s1 != s2);
-    REQUIRE(std::string(s1) == "foo");
-    REQUIRE(std::string(s2) == "bar");
+    REQUIRE(std::string{s1} == "foo");
+    REQUIRE(std::string{s2} == "bar");
 
     auto it = ss.begin();
     REQUIRE(s1 == *it++);
@@ -50,9 +51,9 @@ TEST_CASE("Add zero-length string and longer strings to StringStore") {
     ss.add("yyyyy");
 
     auto it = ss.begin();
-    REQUIRE(std::string(*it++) == "");
-    REQUIRE(std::string(*it++) == "xxx");
-    REQUIRE(std::string(*it++) == "yyyyy");
+    REQUIRE(std::string{*it++}.empty());
+    REQUIRE(std::string{*it++} == "xxx");
+    REQUIRE(std::string{*it++} == "yyyyy");
     REQUIRE(it == ss.end());
 }
 
@@ -66,7 +67,7 @@ TEST_CASE("Add many strings to StringStore") {
         }
 
         for (const char* s : ss) {
-            REQUIRE(std::string(s) == teststring);
+            REQUIRE(std::string{s} == teststring);
             --i;
         }
 
@@ -95,10 +96,10 @@ TEST_CASE("Add strings to StringTable") {
     REQUIRE(st.size() == 4);
 
     auto it = st.begin();
-    REQUIRE(std::string("") == *it++);
-    REQUIRE(std::string("foo") == *it++);
-    REQUIRE(std::string("bar") == *it++);
-    REQUIRE(std::string("baz") == *it++);
+    REQUIRE(std::string{} == *it++);
+    REQUIRE(std::string{"foo"} == *it++);
+    REQUIRE(std::string{"bar"} == *it++);
+    REQUIRE(std::string{"baz"} == *it++);
     REQUIRE(it == st.end());
 
     st.clear();
@@ -129,7 +130,7 @@ TEST_CASE("Lots of strings in string table so chunk overflows") {
     auto it = st.begin();
     REQUIRE(std::string{} == *it++);
     for (int i = 0; i < n; ++i) {
-        REQUIRE(std::atoi(*it++) == i);
+        REQUIRE(osmium::detail::str_to_int<int>(*it++) == i);
     }
     REQUIRE(it == st.end());
 }
diff --git a/third_party/libosmium/test/t/io/test_writer.cpp b/third_party/libosmium/test/t/io/test_writer.cpp
index 9f47b77cbee..350f39307aa 100644
--- a/third_party/libosmium/test/t/io/test_writer.cpp
+++ b/third_party/libosmium/test/t/io/test_writer.cpp
@@ -1,150 +1,184 @@
 #include "catch.hpp"
-#include "utils.hpp"
 
-#include <algorithm>
+#include "utils.hpp"
 
 #include <osmium/io/any_compression.hpp>
+#include <osmium/io/output_iterator.hpp>
 #include <osmium/io/xml_input.hpp>
 #include <osmium/io/xml_output.hpp>
-#include <osmium/io/output_iterator.hpp>
 #include <osmium/memory/buffer.hpp>
 
-TEST_CASE("Writer") {
-    osmium::io::Header header;
-    header.set("generator", "test_writer.cpp");
+#include <algorithm>
+#include <stdexcept>
 
+static osmium::memory::Buffer get_buffer() {
     osmium::io::Reader reader{with_data_dir("t/io/data.osm")};
     osmium::memory::Buffer buffer = reader.read();
     REQUIRE(buffer);
     REQUIRE(buffer.committed() > 0);
+
+    return buffer;
+}
+
+static osmium::memory::Buffer get_and_check_buffer() {
+    auto buffer = get_buffer();
+
     const auto num = std::distance(buffer.select<osmium::OSMObject>().cbegin(), buffer.select<osmium::OSMObject>().cend());
     REQUIRE(num > 0);
     REQUIRE(buffer.select<osmium::OSMObject>().cbegin()->id() == 1);
 
+    return buffer;
+}
+
+TEST_CASE("Writer: Empty writes") {
+    auto buffer = get_and_check_buffer();
+
     std::string filename;
 
-    SECTION("Empty writes") {
-
-        SECTION("Empty buffer") {
-            filename = "test-writer-out-empty-buffer.osm";
-            osmium::io::Writer writer{filename, header, osmium::io::overwrite::allow};
-            osmium::memory::Buffer empty_buffer{1024};
-            writer(std::move(empty_buffer));
-            writer.close();
-        }
-
-        SECTION("Invalid buffer") {
-            filename = "test-writer-out-invalid-buffer.osm";
-            osmium::io::Writer writer{filename, header, osmium::io::overwrite::allow};
-            osmium::memory::Buffer invalid_buffer;
-            writer(std::move(invalid_buffer));
-            writer.close();
-        }
-
-        osmium::io::Reader reader_check{filename};
-        osmium::memory::Buffer buffer_check = reader_check.read();
-        REQUIRE_FALSE(buffer_check);
+    SECTION("Empty buffer") {
+        filename = "test-writer-out-empty-buffer.osm";
+        osmium::io::Writer writer{filename, osmium::io::overwrite::allow};
+        osmium::memory::Buffer empty_buffer{1024};
+        writer(std::move(empty_buffer));
+        writer.close();
     }
 
-    SECTION("Successful writes") {
-
-        SECTION("Writer buffer") {
-            filename = "test-writer-out-buffer.osm";
-            osmium::io::Writer writer{filename, header, osmium::io::overwrite::allow};
-            writer(std::move(buffer));
-            writer.close();
-
-            REQUIRE_THROWS_AS(writer(osmium::memory::Buffer{}), const osmium::io_error&);
-        }
-
-        SECTION("Writer item") {
-            filename = "test-writer-out-item.osm";
-            osmium::io::Writer writer{filename, header, osmium::io::overwrite::allow};
-            for (const auto& item : buffer) {
-                writer(item);
-            }
-            writer.close();
-        }
-
-        SECTION("Writer output iterator") {
-            filename = "test-writer-out-iterator.osm";
-            osmium::io::Writer writer{filename, header, osmium::io::overwrite::allow};
-            auto it = osmium::io::make_output_iterator(writer);
-            std::copy(buffer.cbegin(), buffer.cend(), it);
-            writer.close();
-        }
-
-        osmium::io::Reader reader_check{filename};
-        const osmium::memory::Buffer buffer_check = reader_check.read();
-        REQUIRE(buffer_check);
-        REQUIRE(buffer_check.committed() > 0);
-        REQUIRE(buffer_check.select<osmium::OSMObject>().size() == num);
-        REQUIRE(buffer_check.select<osmium::OSMObject>().cbegin()->id() == 1);
+    SECTION("Invalid buffer") {
+        filename = "test-writer-out-invalid-buffer.osm";
+        osmium::io::Writer writer{filename, osmium::io::overwrite::allow};
+        osmium::memory::Buffer invalid_buffer;
+        writer(std::move(invalid_buffer));
+        writer.close();
     }
 
-    SECTION("Interrupted writer after open") {
-        int error = 0;
-        try {
-            filename = "test-writer-out-fail1.osm";
-            osmium::io::Writer writer{filename, header, osmium::io::overwrite::allow};
-            throw 1;
-        } catch (int e) {
-            error = e;
-        }
-
-        REQUIRE(error > 0);
-    }
+    osmium::io::Reader reader_check{filename};
+    osmium::memory::Buffer buffer_check = reader_check.read();
+    REQUIRE_FALSE(buffer_check);
+}
 
-    SECTION("Interrupted writer after write") {
-        int error = 0;
-        try {
-            filename = "test-writer-out-fail2.osm";
-            osmium::io::Writer writer{filename, header, osmium::io::overwrite::allow};
-            writer(std::move(buffer));
-            throw 2;
-        } catch (int e) {
-            error = e;
-        }
-
-        REQUIRE(error > 0);
-    }
+TEST_CASE("Writer: Successful writes writing buffer") {
+    auto buffer = get_buffer();
+
+    const auto num = std::distance(buffer.select<osmium::OSMObject>().cbegin(), buffer.select<osmium::OSMObject>().cend());
+    REQUIRE(num > 0);
+    REQUIRE(buffer.select<osmium::OSMObject>().cbegin()->id() == 1);
+
+    std::string filename = "test-writer-out-buffer.osm";
+    osmium::io::Writer writer{filename, osmium::io::Header{}, osmium::io::overwrite::allow};
+    writer(std::move(buffer));
+    writer.close();
 
+    REQUIRE_THROWS_AS(writer(osmium::memory::Buffer{}), const osmium::io_error&);
+
+    osmium::io::Reader reader_check{filename};
+    const osmium::memory::Buffer buffer_check = reader_check.read();
+    REQUIRE(buffer_check);
+    REQUIRE(buffer_check.committed() > 0);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == num);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().cbegin()->id() == 1);
 }
 
-TEST_CASE("Writer with user-provided pool") {
-    osmium::io::Header header;
-    header.set("generator", "test_writer.cpp");
+TEST_CASE("Writer: Successful writes writing items") {
+    auto buffer = get_buffer();
 
-    osmium::io::Reader reader{with_data_dir("t/io/data.osm")};
-    osmium::memory::Buffer buffer = reader.read();
-    REQUIRE(buffer);
-    REQUIRE(buffer.committed() > 0);
+    const auto num = std::distance(buffer.select<osmium::OSMObject>().cbegin(), buffer.select<osmium::OSMObject>().cend());
+    REQUIRE(num > 0);
+    REQUIRE(buffer.select<osmium::OSMObject>().cbegin()->id() == 1);
 
-    SECTION("with default number of threads") {
-        osmium::thread::Pool pool;
-        osmium::io::Writer writer{"test-writer-pool-with-default-threads.osm", pool, header, osmium::io::overwrite::allow};
-        writer(std::move(buffer));
-        writer.close();
+    std::string filename = "test-writer-out-item.osm";
+    osmium::io::Writer writer{filename, osmium::io::overwrite::allow};
+    for (const auto& item : buffer) {
+        writer(item);
     }
+    writer.close();
+
+    osmium::io::Reader reader_check{filename};
+    const osmium::memory::Buffer buffer_check = reader_check.read();
+    REQUIRE(buffer_check);
+    REQUIRE(buffer_check.committed() > 0);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == num);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().cbegin()->id() == 1);
+}
 
-    SECTION("with negative number of threads") {
-        osmium::thread::Pool pool{-2};
-        osmium::io::Writer writer{"test-writer-pool-with-negative-threads.osm", header, pool, osmium::io::overwrite::allow};
-        writer(std::move(buffer));
-        writer.close();
-    }
+TEST_CASE("Writer: Successful writes using output iterator") {
+    auto buffer = get_buffer();
 
-    SECTION("with outlier negative number of threads") {
-        osmium::thread::Pool pool{-1000};
-        osmium::io::Writer writer{"test-writer-pool-with-outlier-negative-threads.osm", header, osmium::io::overwrite::allow, pool};
-        writer(std::move(buffer));
-        writer.close();
+    const auto num = std::distance(buffer.select<osmium::OSMObject>().cbegin(), buffer.select<osmium::OSMObject>().cend());
+    REQUIRE(num > 0);
+    REQUIRE(buffer.select<osmium::OSMObject>().cbegin()->id() == 1);
+
+    std::string filename = "test-writer-out-iterator.osm";
+    osmium::io::Writer writer{filename, osmium::io::overwrite::allow};
+    auto it = osmium::io::make_output_iterator(writer);
+    std::copy(buffer.cbegin(), buffer.cend(), it);
+    writer.close();
+
+    osmium::io::Reader reader_check{filename};
+    const osmium::memory::Buffer buffer_check = reader_check.read();
+    REQUIRE(buffer_check);
+    REQUIRE(buffer_check.committed() > 0);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == num);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().cbegin()->id() == 1);
+}
+
+TEST_CASE("Writer: Interrupted writer after open") {
+    auto buffer = get_and_check_buffer();
+
+    bool error = false;
+    try {
+        osmium::io::Writer writer{"test-writer-out-fail1.osm", osmium::io::overwrite::allow};
+        throw std::runtime_error{"some error"};
+    } catch (...) {
+        error = true;
     }
 
-    SECTION("with outlier positive number of threads") {
-        osmium::thread::Pool pool{1000};
-        osmium::io::Writer writer{"test-writer-pool-with-outlier-positive-threads.osm", header, osmium::io::overwrite::allow, pool};
+    REQUIRE(error);
+}
+
+TEST_CASE("Writer: Interrupted writer after write") {
+    auto buffer = get_and_check_buffer();
+
+    bool error = false;
+    try {
+        osmium::io::Writer writer{"test-writer-out-fail2.osm", osmium::io::overwrite::allow};
         writer(std::move(buffer));
-        writer.close();
+        throw std::runtime_error{"some error"};
+    } catch (...) {
+        error = true;
     }
+
+    REQUIRE(error);
+}
+
+TEST_CASE("Writer with user-provided pool with default number of threads") {
+    auto buffer = get_buffer();
+    osmium::thread::Pool pool;
+    osmium::io::Writer writer{"test-writer-pool-with-default-threads.osm", pool, osmium::io::overwrite::allow};
+    writer(std::move(buffer));
+    writer.close();
 }
+
+TEST_CASE("Writer with user-provided pool with negative number of threads") {
+    auto buffer = get_buffer();
+    osmium::thread::Pool pool{-2};
+    osmium::io::Writer writer{"test-writer-pool-with-negative-threads.osm", pool, osmium::io::overwrite::allow};
+    writer(std::move(buffer));
+    writer.close();
+}
+
+TEST_CASE("Writer with user-provided pool with outlier negative number of threads") {
+    auto buffer = get_buffer();
+    osmium::thread::Pool pool{-1000};
+    osmium::io::Writer writer{"test-writer-pool-with-outlier-negative-threads.osm", osmium::io::overwrite::allow, pool};
+    writer(std::move(buffer));
+    writer.close();
+}
+
+TEST_CASE("Writer with user-provided pool with outlier positive number of threads") {
+    auto buffer = get_buffer();
+    osmium::thread::Pool pool{1000};
+    osmium::io::Writer writer{"test-writer-pool-with-outlier-positive-threads.osm", osmium::io::overwrite::allow, pool};
+    writer(std::move(buffer));
+    writer.close();
+}
+
diff --git a/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp b/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp
index c297462510c..bda799baf7e 100644
--- a/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp
+++ b/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp
@@ -1,31 +1,38 @@
-
 #include "catch.hpp"
-#include "utils.hpp"
 
-#include <stdexcept>
-#include <string>
+#include "utils.hpp"
 
 #include <osmium/io/compression.hpp>
 #include <osmium/io/xml_input.hpp>
 #include <osmium/io/xml_output.hpp>
 
+#include <stdexcept>
+#include <string>
+#include <utility>
+
 class MockCompressor : public osmium::io::Compressor {
 
     std::string m_fail_in;
 
 public:
 
-    explicit MockCompressor(const std::string& fail_in) :
+    explicit MockCompressor(std::string fail_in) :
         Compressor(osmium::io::fsync::no),
-        m_fail_in(fail_in) {
+        m_fail_in(std::move(fail_in)) {
         if (m_fail_in == "constructor") {
             throw std::logic_error{"constructor"};
         }
     }
 
+    MockCompressor(const MockCompressor&) = delete;
+    MockCompressor& operator=(const MockCompressor&) = delete;
+
+    MockCompressor(MockCompressor&&) = delete;
+    MockCompressor& operator=(MockCompressor&&) = delete;
+
     ~MockCompressor() noexcept final = default;
 
-    void write(const std::string&) final {
+    void write(const std::string& /*data*/) final {
         if (m_fail_in == "write") {
             throw std::logic_error{"write"};
         }
@@ -56,7 +63,8 @@ TEST_CASE("Write with mock compressor") {
     osmium::memory::Buffer buffer = reader.read();
     REQUIRE(buffer);
     REQUIRE(buffer.committed() > 0);
-    REQUIRE(buffer.select<osmium::OSMObject>().size() > 0);
+    REQUIRE_FALSE(buffer.select<osmium::OSMObject>().empty());
+    REQUIRE(buffer.select<osmium::OSMObject>().size() > 0); // NOLINT(readability-container-size-empty)
 
     SECTION("fail on construction") {
 
diff --git a/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp b/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp
index f57ddbd8c5c..f09f400d650 100644
--- a/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp
+++ b/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp
@@ -1,15 +1,16 @@
-
 #include "catch.hpp"
-#include "utils.hpp"
 
-#include <stdexcept>
-#include <string>
+#include "utils.hpp"
 
 #include <osmium/io/compression.hpp>
 #include <osmium/io/detail/output_format.hpp>
 #include <osmium/io/detail/queue_util.hpp>
-#include <osmium/io/xml_input.hpp>
 #include <osmium/io/writer.hpp>
+#include <osmium/io/xml_input.hpp>
+
+#include <stdexcept>
+#include <string>
+#include <utility>
 
 class MockOutputFormat : public osmium::io::detail::OutputFormat {
 
@@ -17,19 +18,19 @@ class MockOutputFormat : public osmium::io::detail::OutputFormat {
 
 public:
 
-    MockOutputFormat(osmium::thread::Pool& pool, const osmium::io::File&, osmium::io::detail::future_string_queue_type& output_queue, const std::string& fail_in) :
+    MockOutputFormat(osmium::thread::Pool& pool, const osmium::io::File& /*file*/, osmium::io::detail::future_string_queue_type& output_queue, std::string fail_in) :
         OutputFormat(pool, output_queue),
-        m_fail_in(fail_in) {
+        m_fail_in(std::move(fail_in)) {
     }
 
-    void write_header(const osmium::io::Header&) final {
+    void write_header(const osmium::io::Header& /*header*/) final {
         if (m_fail_in == "header") {
             throw std::logic_error{"header"};
         }
         send_to_output_queue(std::string{"header"});
     }
 
-    void write_buffer(osmium::memory::Buffer&&) final {
+    void write_buffer(osmium::memory::Buffer&& /*buffer*/) final {
         if (m_fail_in == "write") {
             throw std::logic_error{"write"};
         }
@@ -62,7 +63,8 @@ TEST_CASE("Test Writer with MockOutputFormat") {
     osmium::memory::Buffer buffer = reader.read();
     REQUIRE(buffer);
     REQUIRE(buffer.committed() > 0);
-    REQUIRE(buffer.select<osmium::OSMObject>().size() > 0);
+    REQUIRE_FALSE(buffer.select<osmium::OSMObject>().empty());
+    REQUIRE(buffer.select<osmium::OSMObject>().size() > 0); // NOLINT(readability-container-size-empty)
 
     SECTION("error in header") {
 
diff --git a/third_party/libosmium/test/t/memory/test_buffer_basics.cpp b/third_party/libosmium/test/t/memory/test_buffer_basics.cpp
index 87c4d46d5d6..e2be4a4c2e2 100644
--- a/third_party/libosmium/test/t/memory/test_buffer_basics.cpp
+++ b/third_party/libosmium/test/t/memory/test_buffer_basics.cpp
@@ -1,10 +1,10 @@
 #include "catch.hpp"
 
+#include <osmium/memory/buffer.hpp>
+
 #include <array>
 #include <stdexcept>
 
-#include <osmium/memory/buffer.hpp>
-
 TEST_CASE("Buffer basics") {
     osmium::memory::Buffer invalid_buffer1;
     osmium::memory::Buffer invalid_buffer2;
diff --git a/third_party/libosmium/test/t/memory/test_buffer_node.cpp b/third_party/libosmium/test/t/memory/test_buffer_node.cpp
index 19718e7abb2..1f939a5fa4e 100644
--- a/third_party/libosmium/test/t/memory/test_buffer_node.cpp
+++ b/third_party/libosmium/test/t/memory/test_buffer_node.cpp
@@ -6,7 +6,7 @@
 void check_node_1(const osmium::Node& node) {
     REQUIRE(1 == node.id());
     REQUIRE(3 == node.version());
-    REQUIRE(true == node.visible());
+    REQUIRE(node.visible());
     REQUIRE(333 == node.changeset());
     REQUIRE(21 == node.uid());
     REQUIRE(123 == uint32_t(node.timestamp()));
@@ -25,7 +25,7 @@ void check_node_1(const osmium::Node& node) {
 void check_node_2(const osmium::Node& node) {
     REQUIRE(2 == node.id());
     REQUIRE(3 == node.version());
-    REQUIRE(true == node.visible());
+    REQUIRE(node.visible());
     REQUIRE(333 == node.changeset());
     REQUIRE(21 == node.uid());
     REQUIRE(123 == uint32_t(node.timestamp()));
@@ -106,7 +106,7 @@ TEST_CASE("Node in Buffer") {
         for (const osmium::memory::Item& item : buffer) {
             REQUIRE(osmium::item_type::node == item.type());
 
-            const osmium::Node& node = static_cast<const osmium::Node&>(item);
+            const auto& node = static_cast<const osmium::Node&>(item);
 
             switch (item_no) {
                 case 0:
diff --git a/third_party/libosmium/test/t/memory/test_callback_buffer.cpp b/third_party/libosmium/test/t/memory/test_callback_buffer.cpp
index 3e94a4026a4..67894fd1307 100644
--- a/third_party/libosmium/test/t/memory/test_callback_buffer.cpp
+++ b/third_party/libosmium/test/t/memory/test_callback_buffer.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
-#include <iterator>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/memory/callback_buffer.hpp>
 
-using namespace osmium::builder::attr;
+#include <iterator>
+
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Callback buffer") {
     osmium::memory::CallbackBuffer cb;
diff --git a/third_party/libosmium/test/t/memory/test_item.cpp b/third_party/libosmium/test/t/memory/test_item.cpp
index 81e18a9cd29..354e86e7600 100644
--- a/third_party/libosmium/test/t/memory/test_item.cpp
+++ b/third_party/libosmium/test/t/memory/test_item.cpp
@@ -10,20 +10,20 @@ TEST_CASE("padded length") {
     REQUIRE(osmium::memory::padded_length(8) ==  8);
     REQUIRE(osmium::memory::padded_length(9) == 16);
 
-    REQUIRE(osmium::memory::padded_length(2147483647) == 2147483648);
-    REQUIRE(osmium::memory::padded_length(2147483648) == 2147483648);
-    REQUIRE(osmium::memory::padded_length(2147483650) == 2147483656);
+    REQUIRE(osmium::memory::padded_length(2147483647ul) == 2147483648ul);
+    REQUIRE(osmium::memory::padded_length(2147483648ul) == 2147483648ul);
+    REQUIRE(osmium::memory::padded_length(2147483650ul) == 2147483656ul);
 
     // The following checks only make sense on a 64 bit system (with
     // sizeof(size_t) == 8), because the numbers are too large for 32 bit.
     // The casts to size_t do nothing on a 64 bit system, on a 32 bit system
     // they bring the numbers into the right range and everything still works.
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967295)) == static_cast<std::size_t>(4294967296));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967296)) == static_cast<std::size_t>(4294967296));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967297)) == static_cast<std::size_t>(4294967304));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967295ull)) == static_cast<std::size_t>(4294967296ull));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967296ull)) == static_cast<std::size_t>(4294967296ull));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967297ull)) == static_cast<std::size_t>(4294967304ull));
 
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(7999999999)) == static_cast<std::size_t>(8000000000));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000000)) == static_cast<std::size_t>(8000000000));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000001)) == static_cast<std::size_t>(8000000008));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(7999999999ull)) == static_cast<std::size_t>(8000000000ull));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000000ull)) == static_cast<std::size_t>(8000000000ull));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000001ull)) == static_cast<std::size_t>(8000000008ull));
 }
 
diff --git a/third_party/libosmium/test/t/memory/test_type_is_compatible.cpp b/third_party/libosmium/test/t/memory/test_type_is_compatible.cpp
index e188111cd6e..83ff0f3ac0c 100644
--- a/third_party/libosmium/test/t/memory/test_type_is_compatible.cpp
+++ b/third_party/libosmium/test/t/memory/test_type_is_compatible.cpp
@@ -1,4 +1,3 @@
-
 #include "catch.hpp"
 
 #include <osmium/memory/item_iterator.hpp>
diff --git a/third_party/libosmium/test/t/osm/test_area.cpp b/third_party/libosmium/test/t/osm/test_area.cpp
index 44514774b03..ea60b2117f7 100644
--- a/third_party/libosmium/test/t/osm/test_area.cpp
+++ b/third_party/libosmium/test/t/osm/test_area.cpp
@@ -1,12 +1,12 @@
 #include "catch.hpp"
 
-#include <boost/crc.hpp>
-
 #include <osmium/builder/attr.hpp>
-#include <osmium/osm/crc.hpp>
 #include <osmium/osm/area.hpp>
+#include <osmium/osm/crc.hpp>
+
+#include <boost/crc.hpp>
 
-using namespace osmium::builder::attr;
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Build area") {
     osmium::memory::Buffer buffer(10000);
@@ -40,7 +40,7 @@ TEST_CASE("Build area") {
 
     REQUIRE(17 == area.id());
     REQUIRE(3 == area.version());
-    REQUIRE(true == area.visible());
+    REQUIRE(area.visible());
     REQUIRE(333 == area.changeset());
     REQUIRE(21 == area.uid());
     REQUIRE(std::string("foo") == area.user());
diff --git a/third_party/libosmium/test/t/osm/test_box.cpp b/third_party/libosmium/test/t/osm/test_box.cpp
index 179ae090aff..324330435c9 100644
--- a/third_party/libosmium/test/t/osm/test_box.cpp
+++ b/third_party/libosmium/test/t/osm/test_box.cpp
@@ -1,15 +1,15 @@
 #include "catch.hpp"
 
-#include <sstream>
+#include <osmium/geom/relations.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/crc.hpp>
 
 #include <boost/crc.hpp>
 
-#include <osmium/osm/box.hpp>
-#include <osmium/osm/crc.hpp>
-#include <osmium/geom/relations.hpp>
+#include <sstream>
 
 TEST_CASE("Default constructor creates invalid box") {
-    const osmium::Box b;
+    const osmium::Box b{};
 
     REQUIRE_FALSE(b);
     REQUIRE_FALSE(b.bottom_left());
@@ -18,7 +18,7 @@ TEST_CASE("Default constructor creates invalid box") {
 }
 
 TEST_CASE("Extend box with undefined") {
-    osmium::Box b;
+    osmium::Box b{};
 
     REQUIRE_FALSE(b);
     b.extend(osmium::Location{});
@@ -28,7 +28,7 @@ TEST_CASE("Extend box with undefined") {
 }
 
 TEST_CASE("Extend box with invalid") {
-    osmium::Box b;
+    osmium::Box b{};
 
     REQUIRE_FALSE(b);
     b.extend(osmium::Location{200.0, 100.0});
@@ -38,7 +38,7 @@ TEST_CASE("Extend box with invalid") {
 }
 
 TEST_CASE("Extend box with valid") {
-    osmium::Box b;
+    osmium::Box b{};
 
     const osmium::Location loc1{1.2, 3.4};
     b.extend(loc1);
@@ -70,7 +70,7 @@ TEST_CASE("Extend box with valid") {
 }
 
 TEST_CASE("Output of defined Box") {
-    osmium::Box b;
+    osmium::Box b{};
 
     b.extend(osmium::Location{1.2, 3.4});
     b.extend(osmium::Location{5.6, 7.8});
@@ -83,7 +83,7 @@ TEST_CASE("Output of defined Box") {
 }
 
 TEST_CASE("Output of undefined Box") {
-    const osmium::Box b;
+    const osmium::Box b{};
 
     std::stringstream out;
     out << b;
@@ -92,7 +92,7 @@ TEST_CASE("Output of undefined Box") {
 }
 
 TEST_CASE("Output of undefined Box (bottom left)") {
-    osmium::Box b;
+    osmium::Box b{};
 
     b.top_right() = osmium::Location(1.2, 3.4);
     std::stringstream out;
@@ -101,7 +101,7 @@ TEST_CASE("Output of undefined Box (bottom left)") {
 }
 
 TEST_CASE("Output of undefined Box (top right)") {
-    osmium::Box b;
+    osmium::Box b{};
 
     b.bottom_left() = osmium::Location(1.2, 3.4);
     std::stringstream out;
@@ -124,15 +124,15 @@ TEST_CASE("Create box from doubles") {
 }
 
 TEST_CASE("Relationship between boxes: contains") {
-    osmium::Box outer;
+    osmium::Box outer{};
     outer.extend(osmium::Location{1, 1});
     outer.extend(osmium::Location{10, 10});
 
-    osmium::Box inner;
+    osmium::Box inner{};
     inner.extend(osmium::Location{2, 2});
     inner.extend(osmium::Location{4, 4});
 
-    osmium::Box overlap;
+    osmium::Box overlap{};
     overlap.extend(osmium::Location{3, 3});
     overlap.extend(osmium::Location{5, 5});
 
@@ -144,19 +144,19 @@ TEST_CASE("Relationship between boxes: contains") {
 }
 
 TEST_CASE("Relationship between boxes: overlaps") {
-    osmium::Box outer;
+    osmium::Box outer{};
     outer.extend(osmium::Location{1, 1});
     outer.extend(osmium::Location{10, 10});
 
-    osmium::Box inner;
+    osmium::Box inner{};
     inner.extend(osmium::Location{2, 2});
     inner.extend(osmium::Location{4, 4});
 
-    osmium::Box overlap;
+    osmium::Box overlap{};
     overlap.extend(osmium::Location{3, 3});
     overlap.extend(osmium::Location{5, 5});
 
-    osmium::Box outside;
+    osmium::Box outside{};
     overlap.extend(osmium::Location{30, 30});
     overlap.extend(osmium::Location{50, 50});
 
diff --git a/third_party/libosmium/test/t/osm/test_changeset.cpp b/third_party/libosmium/test/t/osm/test_changeset.cpp
index 0c1fc423146..64c02667e5b 100644
--- a/third_party/libosmium/test/t/osm/test_changeset.cpp
+++ b/third_party/libosmium/test/t/osm/test_changeset.cpp
@@ -1,12 +1,12 @@
 #include "catch.hpp"
 
-#include <boost/crc.hpp>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/osm/changeset.hpp>
 #include <osmium/osm/crc.hpp>
 
-using namespace osmium::builder::attr;
+#include <boost/crc.hpp>
+
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Build changeset") {
     osmium::memory::Buffer buffer{10 * 1000};
@@ -28,7 +28,7 @@ TEST_CASE("Build changeset") {
     REQUIRE(9 == cs1.uid());
     REQUIRE(7 == cs1.num_changes());
     REQUIRE(3 == cs1.num_comments());
-    REQUIRE(true == cs1.closed());
+    REQUIRE(cs1.closed());
     REQUIRE(osmium::Timestamp(100) == cs1.created_at());
     REQUIRE(osmium::Timestamp(200) == cs1.closed_at());
     REQUIRE(1 == cs1.tags().size());
@@ -57,7 +57,7 @@ TEST_CASE("Build changeset") {
     REQUIRE(9 == cs2.uid());
     REQUIRE(21 == cs2.num_changes());
     REQUIRE(0 == cs2.num_comments());
-    REQUIRE(false == cs2.closed());
+    REQUIRE_FALSE(cs2.closed());
     REQUIRE(osmium::Timestamp(120) == cs2.created_at());
     REQUIRE(osmium::Timestamp() == cs2.closed_at());
     REQUIRE(2 == cs2.tags().size());
@@ -67,8 +67,8 @@ TEST_CASE("Build changeset") {
 
     REQUIRE(cs1 < cs2);
     REQUIRE(cs1 <= cs2);
-    REQUIRE(false == (cs1 > cs2));
-    REQUIRE(false == (cs1 >= cs2));
+    REQUIRE_FALSE(cs1 > cs2);
+    REQUIRE_FALSE(cs1 >= cs2);
 
     auto cit = cs2.discussion().begin();
 
@@ -119,7 +119,7 @@ TEST_CASE("Create changeset without helper") {
     REQUIRE(9 == cs.uid());
     REQUIRE(7 == cs.num_changes());
     REQUIRE(2 == cs.num_comments());
-    REQUIRE(true == cs.closed());
+    REQUIRE(cs.closed());
     REQUIRE(osmium::Timestamp(100) == cs.created_at());
     REQUIRE(osmium::Timestamp(200) == cs.closed_at());
     REQUIRE(2 == cs.tags().size());
diff --git a/third_party/libosmium/test/t/osm/test_crc.cpp b/third_party/libosmium/test/t/osm/test_crc.cpp
index 97c3c4c751f..6f304c1ff41 100644
--- a/third_party/libosmium/test/t/osm/test_crc.cpp
+++ b/third_party/libosmium/test/t/osm/test_crc.cpp
@@ -1,9 +1,9 @@
 #include "catch.hpp"
 
-#include <boost/crc.hpp>
-
 #include <osmium/osm/crc.hpp>
 
+#include <boost/crc.hpp>
+
 TEST_CASE("CRC of bool") {
     osmium::CRC<boost::crc_32_type> crc32;
 
diff --git a/third_party/libosmium/test/t/osm/test_location.cpp b/third_party/libosmium/test/t/osm/test_location.cpp
index a47a49c6f3a..7d50431929b 100644
--- a/third_party/libosmium/test/t/osm/test_location.cpp
+++ b/third_party/libosmium/test/t/osm/test_location.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
+#include <osmium/osm/location.hpp>
+
 #include <limits>
 #include <sstream>
 #include <type_traits>
 
-#include <osmium/osm/location.hpp>
-
 // fails on MSVC and doesn't really matter
 // static_assert(std::is_literal_type<osmium::Location>::value, "osmium::Location not literal type");
 
@@ -169,11 +169,11 @@ TEST_CASE("Location hash") {
     }
 }
 
-void C(const char* s, long v, const char* r = "") {
+void C(const char* s, int32_t v, const char* r = "") {
     std::string strm{"-"};
     strm += s;
-    REQUIRE(std::atof(strm.c_str() + 1) == Approx( v / 10000000.0));
-    REQUIRE(std::atof(strm.c_str()    ) == Approx(-v / 10000000.0));
+    REQUIRE(std::atof(strm.c_str() + 1) == Approx( v / 10000000.0)); // NOLINT(cert-err34-c)
+    REQUIRE(std::atof(strm.c_str()    ) == Approx(-v / 10000000.0)); // NOLINT(cert-err34-c)
     const char* x = strm.c_str() + 1;
     const char** data = &x;
     REQUIRE(osmium::detail::string_to_location_coordinate(data) == v);
@@ -346,7 +346,7 @@ TEST_CASE("Writing zero coordinate into string") {
     REQUIRE(buffer == "0");
 }
 
-void CW(long v, const char* s) {
+void CW(int32_t v, const char* s) {
     std::string buffer;
 
     osmium::detail::append_location_coordinate_to_string(std::back_inserter(buffer), v);
diff --git a/third_party/libosmium/test/t/osm/test_metadata.cpp b/third_party/libosmium/test/t/osm/test_metadata.cpp
new file mode 100644
index 00000000000..c192b386c91
--- /dev/null
+++ b/third_party/libosmium/test/t/osm/test_metadata.cpp
@@ -0,0 +1,173 @@
+#include "catch.hpp"
+
+#include <osmium/builder/attr.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/metadata_options.hpp>
+#include <osmium/osm/object.hpp>
+
+TEST_CASE("Metadata options: default") {
+    const osmium::metadata_options m{};
+    REQUIRE_FALSE(m.none());
+    REQUIRE(m.any());
+    REQUIRE(m.all());
+    REQUIRE(m.version());
+    REQUIRE(m.timestamp());
+    REQUIRE(m.changeset());
+    REQUIRE(m.uid());
+    REQUIRE(m.user());
+}
+
+TEST_CASE("Metadata options: false") {
+    const osmium::metadata_options m{"false"};
+    REQUIRE(m.none());
+    REQUIRE_FALSE(m.any());
+    REQUIRE_FALSE(m.all());
+    REQUIRE_FALSE(m.version());
+    REQUIRE_FALSE(m.timestamp());
+    REQUIRE_FALSE(m.changeset());
+    REQUIRE_FALSE(m.uid());
+    REQUIRE_FALSE(m.user());
+}
+
+TEST_CASE("Metadata options: none") {
+    const osmium::metadata_options m{"none"};
+    REQUIRE(m.none());
+    REQUIRE_FALSE(m.any());
+    REQUIRE_FALSE(m.all());
+    REQUIRE_FALSE(m.version());
+    REQUIRE_FALSE(m.timestamp());
+    REQUIRE_FALSE(m.changeset());
+    REQUIRE_FALSE(m.uid());
+    REQUIRE_FALSE(m.user());
+}
+
+TEST_CASE("Metadata options: true") {
+    const osmium::metadata_options m{"true"};
+    REQUIRE_FALSE(m.none());
+    REQUIRE(m.any());
+    REQUIRE(m.all());
+    REQUIRE(m.version());
+    REQUIRE(m.timestamp());
+    REQUIRE(m.changeset());
+    REQUIRE(m.uid());
+    REQUIRE(m.user());
+}
+
+TEST_CASE("Metadata options: all") {
+    const osmium::metadata_options m{"all"};
+    REQUIRE_FALSE(m.none());
+    REQUIRE(m.any());
+    REQUIRE(m.all());
+    REQUIRE(m.version());
+    REQUIRE(m.timestamp());
+    REQUIRE(m.changeset());
+    REQUIRE(m.uid());
+    REQUIRE(m.user());
+}
+
+TEST_CASE("Metadata options: version,changeset") {
+    const osmium::metadata_options m{"version+changeset"};
+    REQUIRE_FALSE(m.none());
+    REQUIRE(m.any());
+    REQUIRE_FALSE(m.all());
+    REQUIRE(m.version());
+    REQUIRE_FALSE(m.timestamp());
+    REQUIRE(m.changeset());
+    REQUIRE_FALSE(m.uid());
+    REQUIRE_FALSE(m.user());
+}
+
+TEST_CASE("Metadata options: timestamp,uid,user") {
+    const osmium::metadata_options m{"timestamp+uid+user"};
+    REQUIRE_FALSE(m.none());
+    REQUIRE(m.any());
+    REQUIRE_FALSE(m.all());
+    REQUIRE_FALSE(m.version());
+    REQUIRE(m.timestamp());
+    REQUIRE_FALSE(m.changeset());
+    REQUIRE(m.uid());
+    REQUIRE(m.user());
+}
+
+TEST_CASE("Metadata options: fail") {
+    REQUIRE_THROWS_AS(osmium::metadata_options{"timestamp+foo"}, const std::invalid_argument&);
+}
+
+TEST_CASE("Metdata options: constructor using OSMObject") {
+    osmium::memory::Buffer buffer{10 * 1000};
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
+
+    SECTION("only version") {
+        const osmium::OSMObject& obj = buffer.get<osmium::OSMObject>(osmium::builder::add_node(buffer,
+                _id(1),
+                _version(2)));
+        osmium::metadata_options options = osmium::detect_available_metadata(obj);
+        REQUIRE_FALSE(options.user());
+        REQUIRE_FALSE(options.uid());
+        REQUIRE_FALSE(options.changeset());
+        REQUIRE_FALSE(options.timestamp());
+        REQUIRE(options.version());
+    }
+
+    SECTION("full") {
+        const osmium::OSMObject& obj = buffer.get<osmium::OSMObject>(osmium::builder::add_node(buffer,
+                _id(1),
+                _version(2),
+                _timestamp("2018-01-01T23:00:00Z"),
+                _cid(30),
+                _uid(8),
+                _user("foo")));
+        osmium::metadata_options options = osmium::detect_available_metadata(obj);
+        REQUIRE(options.all());
+    }
+
+    SECTION("changeset+timestamp+version") {
+        const osmium::OSMObject& obj = buffer.get<osmium::OSMObject>(osmium::builder::add_node(buffer,
+                _id(1),
+                _version(2),
+                _timestamp("2018-01-01T23:00:00Z"),
+                _cid(30)));
+        osmium::metadata_options options = osmium::detect_available_metadata(obj);
+        REQUIRE(options.version());
+        REQUIRE(options.timestamp());
+        REQUIRE(options.changeset());
+        REQUIRE_FALSE(options.user());
+        REQUIRE_FALSE(options.uid());
+    }
+}
+
+TEST_CASE("Metdata options: string representation should be valid 'version+changeset'") {
+    const osmium::metadata_options options{"version+changeset"};
+    REQUIRE(options.to_string() == "version+changeset");
+}
+
+TEST_CASE("Metdata options: string representation should be valid 'version+uid+user'") {
+    const osmium::metadata_options options{"version+uid+user"};
+    REQUIRE(options.to_string() == "version+uid+user");
+}
+
+TEST_CASE("Metdata options: string representation should be valid 'version+timestamp'") {
+    const osmium::metadata_options options{"version+timestamp"};
+    REQUIRE(options.to_string() == "version+timestamp");
+}
+
+TEST_CASE("Metdata options: string representation should be valid 'timestamp+version (different order'") {
+    const osmium::metadata_options options{"timestamp+version"};
+    REQUIRE(options.to_string() == "version+timestamp");
+}
+
+TEST_CASE("Metdata options: string representation should be valid 'none'") {
+    const osmium::metadata_options options{"none"};
+    REQUIRE(options.to_string() == "none");
+}
+
+TEST_CASE("Metdata options: string representation should be valid 'all (short)'") {
+    const osmium::metadata_options options{"all"};
+    REQUIRE(options.to_string() == "all");
+}
+
+TEST_CASE("Metdata options: string representation should be valid 'all (long)'") {
+    const osmium::metadata_options options{"user+uid+version+timestamp+changeset"};
+    REQUIRE(options.to_string() == "all");
+}
+
diff --git a/third_party/libosmium/test/t/osm/test_node.cpp b/third_party/libosmium/test/t/osm/test_node.cpp
index 752e6af70c2..06b6dcbe52b 100644
--- a/third_party/libosmium/test/t/osm/test_node.cpp
+++ b/third_party/libosmium/test/t/osm/test_node.cpp
@@ -1,12 +1,12 @@
 #include "catch.hpp"
 
-#include <boost/crc.hpp>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/osm/crc.hpp>
 #include <osmium/osm/node.hpp>
 
-using namespace osmium::builder::attr;
+#include <boost/crc.hpp>
+
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Build node") {
     osmium::memory::Buffer buffer{10000};
@@ -24,7 +24,7 @@ TEST_CASE("Build node") {
         _location(3.5, 4.7)
     );
 
-    osmium::Node& node = buffer.get<osmium::Node>(0);
+    auto& node = buffer.get<osmium::Node>(0);
 
     REQUIRE(osmium::item_type::node == node.type());
     REQUIRE(node.type_is_in(osmium::osm_entity_bits::node));
@@ -32,8 +32,8 @@ TEST_CASE("Build node") {
     REQUIRE(17l == node.id());
     REQUIRE(17ul == node.positive_id());
     REQUIRE(3 == node.version());
-    REQUIRE(true == node.visible());
-    REQUIRE(false == node.deleted());
+    REQUIRE(node.visible());
+    REQUIRE_FALSE(node.deleted());
     REQUIRE(333 == node.changeset());
     REQUIRE(21 == node.uid());
     REQUIRE(std::string{"foo"} == node.user());
@@ -46,8 +46,8 @@ TEST_CASE("Build node") {
     REQUIRE(crc32().checksum() == 0x7dc553f9);
 
     node.set_visible(false);
-    REQUIRE(false == node.visible());
-    REQUIRE(true == node.deleted());
+    REQUIRE_FALSE(node.visible());
+    REQUIRE(node.deleted());
 }
 
 TEST_CASE("default values for node attributes") {
@@ -59,13 +59,13 @@ TEST_CASE("default values for node attributes") {
     REQUIRE(0l == node.id());
     REQUIRE(0ul == node.positive_id());
     REQUIRE(0 == node.version());
-    REQUIRE(true == node.visible());
+    REQUIRE(node.visible());
     REQUIRE(0 == node.changeset());
     REQUIRE(0 == node.uid());
     REQUIRE(std::string{} == node.user());
     REQUIRE(0 == uint32_t(node.timestamp()));
     REQUIRE(osmium::Location() == node.location());
-    REQUIRE(0 == node.tags().size());
+    REQUIRE(node.tags().empty());
 }
 
 TEST_CASE("set node attributes from strings") {
@@ -73,7 +73,7 @@ TEST_CASE("set node attributes from strings") {
 
     osmium::builder::add_node(buffer, _id(0));
 
-    osmium::Node& node = buffer.get<osmium::Node>(0);
+    auto& node = buffer.get<osmium::Node>(0);
     node.set_id("-17")
         .set_version("3")
         .set_visible("true")
@@ -84,7 +84,7 @@ TEST_CASE("set node attributes from strings") {
     REQUIRE(-17l == node.id());
     REQUIRE(17ul == node.positive_id());
     REQUIRE(3 == node.version());
-    REQUIRE(true == node.visible());
+    REQUIRE(node.visible());
     REQUIRE(333 == node.changeset());
     REQUIRE(std::string{"2014-03-17T16:23:08Z"} == node.timestamp().to_iso());
     REQUIRE(21 == node.uid());
@@ -95,7 +95,7 @@ TEST_CASE("set node attributes from strings using set_attribute()") {
 
     osmium::builder::add_node(buffer, _id(0));
 
-    osmium::Node& node = buffer.get<osmium::Node>(0);
+    auto& node = buffer.get<osmium::Node>(0);
     node.set_attribute("id", "-17")
         .set_attribute("version", "3")
         .set_attribute("visible", "true")
@@ -106,7 +106,7 @@ TEST_CASE("set node attributes from strings using set_attribute()") {
     REQUIRE(-17l == node.id());
     REQUIRE(17ul == node.positive_id());
     REQUIRE(3 == node.version());
-    REQUIRE(true == node.visible());
+    REQUIRE(node.visible());
     REQUIRE(333 == node.changeset());
     REQUIRE(std::string{"2014-03-17T16:23:08Z"} == node.timestamp().to_iso());
     REQUIRE(21 == node.uid());
@@ -117,7 +117,7 @@ TEST_CASE("Setting attributes from bad data on strings should fail") {
 
     osmium::builder::add_node(buffer, _id(0));
 
-    osmium::Node& node = buffer.get<osmium::Node>(0);
+    auto& node = buffer.get<osmium::Node>(0);
     REQUIRE_THROWS(node.set_id("bar"));
     REQUIRE_THROWS(node.set_id("123x"));
     REQUIRE_THROWS(node.set_version("123x"));
@@ -136,7 +136,7 @@ TEST_CASE("set large id") {
     const int64_t id = 3000000000l;
     osmium::builder::add_node(buffer, _id(id));
 
-    osmium::Node& node = buffer.get<osmium::Node>(0);
+    auto& node = buffer.get<osmium::Node>(0);
     REQUIRE(id == node.id());
     REQUIRE(static_cast<osmium::unsigned_object_id_type>(id) == node.positive_id());
 
@@ -169,7 +169,7 @@ TEST_CASE("Setting diff flags on node") {
 
     osmium::builder::add_node(buffer, _id(17));
 
-    osmium::Node& node = buffer.get<osmium::Node>(0);
+    auto& node = buffer.get<osmium::Node>(0);
 
     REQUIRE(node.diff() == osmium::diff_indicator_type::none);
     REQUIRE(node.diff_as_char() == '*');
diff --git a/third_party/libosmium/test/t/osm/test_node_ref.cpp b/third_party/libosmium/test/t/osm/test_node_ref.cpp
index 3494d2aee08..8a6c30dcea2 100644
--- a/third_party/libosmium/test/t/osm/test_node_ref.cpp
+++ b/third_party/libosmium/test/t/osm/test_node_ref.cpp
@@ -66,7 +66,7 @@ TEST_CASE("WayNodeList") {
 
         const osmium::WayNodeList& nrl = buffer.get<osmium::WayNodeList>(0);
         REQUIRE(nrl.empty());
-        REQUIRE(nrl.size() == 0);
+        REQUIRE(nrl.size() == 0); // NOLINT(readability-container-size-empty)
     }
 
     SECTION("Change a WayNodeList") {
@@ -76,7 +76,7 @@ TEST_CASE("WayNodeList") {
             {3, {1.0, 1.0}}
         }));
 
-        osmium::WayNodeList& nrl = buffer.get<osmium::WayNodeList>(0);
+        auto& nrl = buffer.get<osmium::WayNodeList>(0);
         REQUIRE(nrl.size() == 3);
 
         REQUIRE(nrl[1].location() == osmium::Location(0.0, 1.0));
diff --git a/third_party/libosmium/test/t/osm/test_object_comparisons.cpp b/third_party/libosmium/test/t/osm/test_object_comparisons.cpp
index 27ded917e84..3db92842d7a 100644
--- a/third_party/libosmium/test/t/osm/test_object_comparisons.cpp
+++ b/third_party/libosmium/test/t/osm/test_object_comparisons.cpp
@@ -1,24 +1,24 @@
 #include "catch.hpp"
 
-#include <algorithm>
-#include <functional>
-#include <vector>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/osm.hpp>
 #include <osmium/osm/object_comparisons.hpp>
 
-using namespace osmium::builder::attr;
+#include <algorithm>
+#include <functional>
+#include <vector>
+
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Object ID comparisons") {
-    osmium::object_id_type a =   0;
-    osmium::object_id_type b =  -1;
-    osmium::object_id_type c = -10;
-    osmium::object_id_type d = -11;
-    osmium::object_id_type e =   1;
-    osmium::object_id_type f =  11;
-    osmium::object_id_type g =  12;
+    const osmium::object_id_type a =   0;
+    const osmium::object_id_type b =  -1;
+    const osmium::object_id_type c = -10;
+    const osmium::object_id_type d = -11;
+    const osmium::object_id_type e =   1;
+    const osmium::object_id_type f =  11;
+    const osmium::object_id_type g =  12;
 
     REQUIRE_FALSE(osmium::id_order{}(a, a));
     REQUIRE(osmium::id_order{}(a, b));
@@ -79,7 +79,7 @@ TEST_CASE("Object ID comparisons") {
 
 TEST_CASE("Node comparisons") {
 
-    osmium::memory::Buffer buffer(10 * 1000);
+    osmium::memory::Buffer buffer{10 * 1000};
     std::vector<std::reference_wrapper<osmium::Node>> nodes;
 
     SECTION("nodes are ordered by id, version, and timestamp") {
@@ -129,18 +129,33 @@ TEST_CASE("Node comparisons") {
 
 }
 
-TEST_CASE("Object comparisons") {
-
-    osmium::memory::Buffer buffer(10 * 1000);
+TEST_CASE("Object comparisons: types are ordered nodes, then ways, then relations") {
+    osmium::memory::Buffer buffer{10 * 1000};
     std::vector<std::reference_wrapper<osmium::OSMObject>> objects;
 
-    SECTION("types are ordered nodes, then ways, then relations") {
-        objects.emplace_back(buffer.get<osmium::Node>(    osmium::builder::add_node(    buffer, _id(3))));
-        objects.emplace_back(buffer.get<osmium::Way>(     osmium::builder::add_way(     buffer, _id(2))));
-        objects.emplace_back(buffer.get<osmium::Relation>(osmium::builder::add_relation(buffer, _id(1))));
+    objects.emplace_back(buffer.get<osmium::Node>(    osmium::builder::add_node(    buffer, _id(3))));
+    objects.emplace_back(buffer.get<osmium::Way>(     osmium::builder::add_way(     buffer, _id(2))));
+    objects.emplace_back(buffer.get<osmium::Relation>(osmium::builder::add_relation(buffer, _id(1))));
+
+    REQUIRE(std::is_sorted(objects.cbegin(), objects.cend()));
+}
 
-        REQUIRE(std::is_sorted(objects.cbegin(), objects.cend()));
+TEST_CASE("Object comparisons with partially missing timestamp") {
+    osmium::memory::Buffer buffer{10 * 1000};
+    osmium::OSMObject& obj1 = buffer.get<osmium::Node>(    osmium::builder::add_node(    buffer,
+            _id(3), _version(2), _timestamp(("2016-01-01T00:00:00Z"))));
+    osmium::OSMObject& obj2 = buffer.get<osmium::Node>(    osmium::builder::add_node(    buffer,
+            _id(3), _version(2)));
+
+    SECTION("OSMObject::operator<") {
+        REQUIRE_FALSE(obj1 < obj2);
+        REQUIRE_FALSE(obj1 > obj2);
+        REQUIRE(obj1 == obj2);
     }
 
+    SECTION("object_order_type_id_reverse_version") {
+        const osmium::object_order_type_id_reverse_version comp{};
+        REQUIRE_FALSE(comp(obj1, obj2));
+        REQUIRE_FALSE(comp(obj2, obj1));
+    }
 }
-
diff --git a/third_party/libosmium/test/t/osm/test_relation.cpp b/third_party/libosmium/test/t/osm/test_relation.cpp
index dc6c2515c42..cde348892cc 100644
--- a/third_party/libosmium/test/t/osm/test_relation.cpp
+++ b/third_party/libosmium/test/t/osm/test_relation.cpp
@@ -1,15 +1,15 @@
 #include "catch.hpp"
 
-#include <boost/crc.hpp>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/osm/crc.hpp>
 #include <osmium/osm/relation.hpp>
 
-using namespace osmium::builder::attr;
+#include <boost/crc.hpp>
+
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Build relation") {
-    osmium::memory::Buffer buffer(10000);
+    osmium::memory::Buffer buffer{10000};
 
     osmium::builder::add_relation(buffer,
         _id(17),
@@ -30,7 +30,7 @@ TEST_CASE("Build relation") {
 
     REQUIRE(17 == relation.id());
     REQUIRE(3 == relation.version());
-    REQUIRE(true == relation.visible());
+    REQUIRE(relation.visible());
     REQUIRE(333 == relation.changeset());
     REQUIRE(21 == relation.uid());
     REQUIRE(std::string("foo") == relation.user());
@@ -64,9 +64,9 @@ TEST_CASE("Build relation") {
 }
 
 TEST_CASE("Member role too long") {
-    osmium::memory::Buffer buffer(10000);
+    osmium::memory::Buffer buffer{10000};
 
-    osmium::builder::RelationMemberListBuilder builder(buffer);
+    osmium::builder::RelationMemberListBuilder builder{buffer};
 
     const char role[2000] = "";
     builder.add_member(osmium::item_type::node, 1, role, 1024);
diff --git a/third_party/libosmium/test/t/osm/test_timestamp.cpp b/third_party/libosmium/test/t/osm/test_timestamp.cpp
index 12d85017332..97546dc13a2 100644
--- a/third_party/libosmium/test/t/osm/test_timestamp.cpp
+++ b/third_party/libosmium/test/t/osm/test_timestamp.cpp
@@ -1,22 +1,22 @@
 #include "catch.hpp"
 
+#include <osmium/osm/timestamp.hpp>
+
 #include <sstream>
 #include <string>
 #include <vector>
 
-#include <osmium/osm/timestamp.hpp>
-
 TEST_CASE("Timestamp can be default initialized to invalid value") {
-    const osmium::Timestamp t;
+    const osmium::Timestamp t{};
     REQUIRE(0 == uint32_t(t));
-    REQUIRE("" == t.to_iso());
+    REQUIRE(t.to_iso().empty());
     REQUIRE_FALSE(t.valid());
 }
 
 TEST_CASE("Timestamp invalid value is zero") {
     const osmium::Timestamp t{static_cast<time_t>(0)};
     REQUIRE(0 == uint32_t(t));
-    REQUIRE("" == t.to_iso());
+    REQUIRE(t.to_iso().empty());
     REQUIRE_FALSE(t.valid());
 }
 
@@ -74,8 +74,39 @@ TEST_CASE("Timestamp can be written to stream") {
     REQUIRE("1970-01-01T00:00:01Z" == ss.str());
 }
 
-TEST_CASE("Valid timestamps") {
+void test_int2_to_string(int value, const char* ref) {
+    std::string s;
+    osmium::detail::add_2digit_int_to_string(value, s);
+    REQUIRE(s == ref);
+}
+
+void test_int4_to_string(int value, const char* ref) {
+    std::string s;
+    osmium::detail::add_4digit_int_to_string(value, s);
+    REQUIRE(s == ref);
+}
+
+TEST_CASE("Write two digit numbers") {
+    test_int2_to_string( 0, "00");
+    test_int2_to_string( 1, "01");
+    test_int2_to_string( 2, "02");
+    test_int2_to_string( 3, "03");
+    test_int2_to_string( 4, "04");
+    test_int2_to_string( 9, "09");
+    test_int2_to_string(10, "10");
+    test_int2_to_string(20, "20");
+    test_int2_to_string(29, "29");
+    test_int2_to_string(99, "99");
+}
 
+TEST_CASE("Write four digit numbers") {
+    test_int4_to_string(1000, "1000");
+    test_int4_to_string(1001, "1001");
+    test_int4_to_string(2018, "2018");
+    test_int4_to_string(9999, "9999");
+}
+
+TEST_CASE("Valid timestamps") {
     std::vector<std::string> test_cases = {
         "1970-01-01T00:00:01Z",
         "2000-01-01T00:00:00Z",
@@ -89,7 +120,6 @@ TEST_CASE("Valid timestamps") {
         const osmium::Timestamp t{tc};
         REQUIRE(tc == t.to_iso());
     }
-
 }
 
 TEST_CASE("Invalid timestamps") {
diff --git a/third_party/libosmium/test/t/osm/test_types_from_string.cpp b/third_party/libosmium/test/t/osm/test_types_from_string.cpp
index 0ea566e2116..1cc7c3a8903 100644
--- a/third_party/libosmium/test/t/osm/test_types_from_string.cpp
+++ b/third_party/libosmium/test/t/osm/test_types_from_string.cpp
@@ -54,45 +54,76 @@ TEST_CASE("set type and ID from string") {
 TEST_CASE("set object version from string") {
     REQUIRE(osmium::string_to_object_version("0") == 0);
     REQUIRE(osmium::string_to_object_version("1") == 1);
+    REQUIRE(osmium::string_to_object_version("-1") == 0);
+    REQUIRE(osmium::string_to_object_version("4294967294") == 4294967294);
 
-    REQUIRE_THROWS_AS(osmium::string_to_object_version("-1"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version("-2"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_object_version(""), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_object_version(" "), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_object_version(" 22"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_object_version("x"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version("4294967295"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version("999999999999"), const std::range_error&);
 }
 
 TEST_CASE("set changeset id from string") {
     REQUIRE(osmium::string_to_changeset_id("0") == 0);
     REQUIRE(osmium::string_to_changeset_id("1") == 1);
+    REQUIRE(osmium::string_to_changeset_id("-1") == 0);
+    REQUIRE(osmium::string_to_changeset_id("4294967294") == 4294967294);
 
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("-1"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("-2"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_changeset_id(""), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_changeset_id(" "), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_changeset_id(" 22"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_changeset_id("x"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("4294967295"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("999999999999"), const std::range_error&);
 }
 
 TEST_CASE("set user id from string") {
     REQUIRE(osmium::string_to_user_id("0") == 0);
     REQUIRE(osmium::string_to_user_id("1") == 1);
     REQUIRE(osmium::string_to_user_id("-1") == -1);
+    REQUIRE(osmium::string_to_user_id("2147483647") == 2147483647);
 
     REQUIRE_THROWS_AS(osmium::string_to_user_id("-2"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_user_id(""), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_user_id(" "), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_user_id(" 22"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_user_id("x"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_user_id("2147483648"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_user_id("4294967295"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_user_id("999999999999"), const std::range_error&);
+}
+
+TEST_CASE("set uid from string") {
+    REQUIRE(osmium::string_to_uid("0") == 0);
+    REQUIRE(osmium::string_to_uid("1") == 1);
+    REQUIRE(osmium::string_to_uid("-1") == 0);
+    REQUIRE(osmium::string_to_uid("4294967294") == 4294967294);
+
+    REQUIRE_THROWS_AS(osmium::string_to_uid("-2"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_uid(""), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_uid(" "), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_uid(" 22"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_uid("x"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_uid("4294967295"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_uid("999999999999"), const std::range_error&);
 }
 
 TEST_CASE("set num changes from string") {
     REQUIRE(osmium::string_to_num_changes("0") == 0);
     REQUIRE(osmium::string_to_num_changes("1") == 1);
+    REQUIRE(osmium::string_to_num_changes("-1") == 0);
+    REQUIRE(osmium::string_to_num_changes("4294967294") == 4294967294);
 
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes("-1"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes("-2"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_num_changes(""), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_num_changes(" "), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_num_changes(" 22"), const std::range_error&);
     REQUIRE_THROWS_AS(osmium::string_to_num_changes("x"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes("4294967295"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes("999999999999"), const std::range_error&);
 }
 
diff --git a/third_party/libosmium/test/t/osm/test_way.cpp b/third_party/libosmium/test/t/osm/test_way.cpp
index bbfcfc90f1a..d91a731dfd1 100644
--- a/third_party/libosmium/test/t/osm/test_way.cpp
+++ b/third_party/libosmium/test/t/osm/test_way.cpp
@@ -1,13 +1,13 @@
 #include "catch.hpp"
 
-#include <boost/crc.hpp>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/osm/crc.hpp>
 #include <osmium/osm/way.hpp>
 
-using namespace osmium::builder::attr;
+#include <boost/crc.hpp>
+
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("Build way") {
     osmium::memory::Buffer buffer{10000};
@@ -32,7 +32,7 @@ TEST_CASE("Build way") {
     REQUIRE(way.type_is_in(osmium::osm_entity_bits::node | osmium::osm_entity_bits::way));
     REQUIRE(17 == way.id());
     REQUIRE(3 == way.version());
-    REQUIRE(true == way.visible());
+    REQUIRE(way.visible());
     REQUIRE(333 == way.changeset());
     REQUIRE(21 == way.uid());
     REQUIRE(std::string("foo") == way.user());
diff --git a/third_party/libosmium/test/t/relations/test_members_database.cpp b/third_party/libosmium/test/t/relations/test_members_database.cpp
index f2a4691ea2f..3aea6669936 100644
--- a/third_party/libosmium/test/t/relations/test_members_database.cpp
+++ b/third_party/libosmium/test/t/relations/test_members_database.cpp
@@ -7,7 +7,7 @@
 #include <osmium/storage/item_stash.hpp>
 
 osmium::memory::Buffer fill_buffer() {
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
     osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_relation(buffer,
@@ -98,7 +98,7 @@ TEST_CASE("Fill member database") {
 }
 
 TEST_CASE("Member database with duplicate member in relation") {
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
     osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_relation(buffer,
diff --git a/third_party/libosmium/test/t/relations/test_read_relations.cpp b/third_party/libosmium/test/t/relations/test_read_relations.cpp
index 5e79133fc4a..e21f28d2340 100644
--- a/third_party/libosmium/test/t/relations/test_read_relations.cpp
+++ b/third_party/libosmium/test/t/relations/test_read_relations.cpp
@@ -1,4 +1,5 @@
 #include "catch.hpp"
+
 #include "utils.hpp"
 
 #include <osmium/handler.hpp>
@@ -13,7 +14,7 @@ class TestHandler : public osmium::handler::Handler {
     int count = 0;
     bool prep = false;
 
-    void relation(const osmium::Relation&) noexcept {
+    void relation(const osmium::Relation& /*relation*/) noexcept {
         ++count;
     }
 
diff --git a/third_party/libosmium/test/t/relations/test_relations_database.cpp b/third_party/libosmium/test/t/relations/test_relations_database.cpp
index e352ea516bd..7443490e704 100644
--- a/third_party/libosmium/test/t/relations/test_relations_database.cpp
+++ b/third_party/libosmium/test/t/relations/test_relations_database.cpp
@@ -6,7 +6,7 @@
 #include <osmium/storage/item_stash.hpp>
 
 osmium::memory::Buffer fill_buffer() {
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
     osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_relation(buffer,
diff --git a/third_party/libosmium/test/t/relations/test_relations_manager.cpp b/third_party/libosmium/test/t/relations/test_relations_manager.cpp
index d7ea12f5084..954cbb85c8c 100644
--- a/third_party/libosmium/test/t/relations/test_relations_manager.cpp
+++ b/third_party/libosmium/test/t/relations/test_relations_manager.cpp
@@ -1,4 +1,5 @@
 #include "catch.hpp"
+
 #include "utils.hpp"
 
 #include <osmium/io/xml_input.hpp>
diff --git a/third_party/libosmium/test/t/storage/test_item_stash.cpp b/third_party/libosmium/test/t/storage/test_item_stash.cpp
index 62d910efb2e..c6fabf2fb5c 100644
--- a/third_party/libosmium/test/t/storage/test_item_stash.cpp
+++ b/third_party/libosmium/test/t/storage/test_item_stash.cpp
@@ -1,13 +1,12 @@
-
-#include <catch.hpp>
-
-#include <sstream>
+#include "catch.hpp"
 
 #include <osmium/builder/attr.hpp>
 #include <osmium/storage/item_stash.hpp>
 
+#include <sstream>
+
 osmium::memory::Buffer generate_test_data() {
-    using namespace osmium::builder::attr;
+    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
     osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
 
@@ -79,7 +78,7 @@ TEST_CASE("Item stash") {
             handle = osmium::ItemStash::handle_type{};
         }
 
-        id++;
+        ++id;
     }
 
     REQUIRE(stash.size() == 120);
@@ -101,7 +100,7 @@ TEST_CASE("Item stash") {
         } else {
             ++count_invalid;
         }
-        id++;
+        ++id;
     }
 
     REQUIRE(count_valid   == 120);
@@ -122,7 +121,7 @@ TEST_CASE("Item stash") {
             const auto& obj = static_cast<const osmium::OSMObject&>(item);
             REQUIRE(obj.id() == id);
         }
-        id++;
+        ++id;
     }
 
     stash.clear();
diff --git a/third_party/libosmium/test/t/tags/test_filter.cpp b/third_party/libosmium/test/t/tags/test_filter.cpp
index 6c15a8048bc..0d0eddf5093 100644
--- a/third_party/libosmium/test/t/tags/test_filter.cpp
+++ b/third_party/libosmium/test/t/tags/test_filter.cpp
@@ -1,13 +1,13 @@
 #include "catch.hpp"
 
-#include <algorithm>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm/tag.hpp>
-#include <osmium/tags/taglist.hpp>
 #include <osmium/tags/filter.hpp>
 #include <osmium/tags/regex_filter.hpp>
+#include <osmium/tags/taglist.hpp>
+
+#include <algorithm>
 
 template <class TFilter>
 void check_filter(const osmium::TagList& tag_list,
diff --git a/third_party/libosmium/test/t/tags/test_operators.cpp b/third_party/libosmium/test/t/tags/test_operators.cpp
index b90303ae832..d3be7e8b9a1 100644
--- a/third_party/libosmium/test/t/tags/test_operators.cpp
+++ b/third_party/libosmium/test/t/tags/test_operators.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
-#include <iterator>
-
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm/tag.hpp>
 
+#include <iterator>
+
 TEST_CASE("Equality comparison of tags") {
     osmium::memory::Buffer buffer1{10240};
     {
@@ -23,8 +23,8 @@ TEST_CASE("Equality comparison of tags") {
     }
     buffer2.commit();
 
-    const osmium::TagList& tl1 = buffer1.get<const osmium::TagList>(0);
-    const osmium::TagList& tl2 = buffer2.get<const osmium::TagList>(0);
+    const auto& tl1 = buffer1.get<const osmium::TagList>(0);
+    const auto& tl2 = buffer2.get<const osmium::TagList>(0);
 
     auto tagit1 = tl1.begin();
     auto tagit2 = tl2.begin();
@@ -44,7 +44,7 @@ TEST_CASE("Ordering of tags") {
     }
     buffer.commit();
 
-    const osmium::TagList& tl = buffer.get<const osmium::TagList>(0);
+    const auto& tl = buffer.get<const osmium::TagList>(0);
     const osmium::Tag& t1 = *(tl.begin());
     const osmium::Tag& t2 = *(std::next(tl.begin(), 1));
     const osmium::Tag& t3 = *(std::next(tl.begin(), 2));
diff --git a/third_party/libosmium/test/t/tags/test_tag_list.cpp b/third_party/libosmium/test/t/tags/test_tag_list.cpp
index db3f1654397..e9612c9ebcc 100644
--- a/third_party/libosmium/test/t/tags/test_tag_list.cpp
+++ b/third_party/libosmium/test/t/tags/test_tag_list.cpp
@@ -1,14 +1,14 @@
 #include "catch.hpp"
 
-#include <map>
-#include <vector>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/builder/builder_helper.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm/tag.hpp>
 
-using namespace osmium::builder::attr;
+#include <map>
+#include <vector>
+
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
 TEST_CASE("create tag list") {
     osmium::memory::Buffer buffer{10240};
diff --git a/third_party/libosmium/test/t/tags/test_tag_matcher.cpp b/third_party/libosmium/test/t/tags/test_tag_matcher.cpp
index d4980620a30..a1f6b7c27b7 100644
--- a/third_party/libosmium/test/t/tags/test_tag_matcher.cpp
+++ b/third_party/libosmium/test/t/tags/test_tag_matcher.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
-#include <type_traits>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/tags/matcher.hpp>
 
+#include <type_traits>
+
 static_assert(std::is_default_constructible<osmium::TagMatcher>::value, "TagMatcher should be default constructible");
 static_assert(std::is_copy_constructible<osmium::TagMatcher>::value, "TagMatcher should be copy constructible");
 static_assert(std::is_move_constructible<osmium::TagMatcher>::value, "TagMatcher should be move constructible");
@@ -23,6 +23,29 @@ TEST_CASE("Tag matcher") {
     }));
     const osmium::TagList& tag_list = buffer.get<osmium::TagList>(pos);
 
+    SECTION("Matching nothing (default constructor)") {
+        osmium::TagMatcher m{};
+        REQUIRE_FALSE(m(tag_list));
+
+        REQUIRE_FALSE(m(*tag_list.begin()));
+    }
+
+    SECTION("Matching nothing (bool)") {
+        osmium::TagMatcher m{false};
+        REQUIRE_FALSE(m(tag_list));
+
+        REQUIRE_FALSE(m(*tag_list.begin()));
+    }
+
+    SECTION("Matching everything") {
+        osmium::TagMatcher m{true};
+        REQUIRE(m(tag_list));
+
+        REQUIRE(m(*tag_list.begin()));
+        REQUIRE(m(*std::next(tag_list.begin())));
+        REQUIRE(m(*std::next(std::next(tag_list.begin()))));
+    }
+
     SECTION("Matching keys only") {
         osmium::TagMatcher m{osmium::StringMatcher::equal{"highway"}};
         REQUIRE(m(tag_list));
@@ -91,3 +114,27 @@ TEST_CASE("Tag matcher") {
     }
 }
 
+TEST_CASE("Copy and move tag matcher") {
+    osmium::TagMatcher m1{"highway"};
+    osmium::TagMatcher c1{true};
+    osmium::TagMatcher c2{false};
+
+    auto m2 = m1;
+
+    REQUIRE(m2("highway", "residential"));
+    REQUIRE_FALSE(m2("name", "High Street"));
+
+    c1 = m1;
+    REQUIRE(c1("highway", "residential"));
+    REQUIRE_FALSE(c1("name", "High Street"));
+
+    auto m3 = std::move(m2);
+
+    REQUIRE(m3("highway", "residential"));
+    REQUIRE_FALSE(m3("name", "High Street"));
+
+    c1 = std::move(c2);
+    REQUIRE_FALSE(c1("highway", "residential"));
+    REQUIRE_FALSE(c1("name", "High Street"));
+}
+
diff --git a/third_party/libosmium/test/t/tags/test_tags_filter.cpp b/third_party/libosmium/test/t/tags/test_tags_filter.cpp
index a537228c531..1b8f363966f 100644
--- a/third_party/libosmium/test/t/tags/test_tags_filter.cpp
+++ b/third_party/libosmium/test/t/tags/test_tags_filter.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
-#include <functional>
-
 #include <osmium/builder/attr.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/tags/tags_filter.hpp>
 
+#include <functional>
+
 TEST_CASE("Tags filter") {
     osmium::memory::Buffer buffer{10240};
 
diff --git a/third_party/libosmium/test/t/thread/test_pool.cpp b/third_party/libosmium/test/t/thread/test_pool.cpp
index 567d8de0ad7..e2b1075ee10 100644
--- a/third_party/libosmium/test/t/thread/test_pool.cpp
+++ b/third_party/libosmium/test/t/thread/test_pool.cpp
@@ -1,12 +1,12 @@
 #include "catch.hpp"
 
+#include <osmium/thread/pool.hpp>
+#include <osmium/util/compatibility.hpp>
+
 #include <chrono>
 #include <stdexcept>
 #include <thread>
 
-#include <osmium/thread/pool.hpp>
-#include <osmium/util/compatibility.hpp>
-
 struct test_job_with_result {
     int operator()() const {
         return 42;
@@ -97,7 +97,7 @@ TEST_CASE("thread (user-provided pool)") {
     SECTION("can get access to thread pool") {
         REQUIRE(pool.queue_empty());
     }
-    
+
     SECTION("can access user-provided number of threads") {
         REQUIRE(pool.num_threads() == 7);
     }
diff --git a/third_party/libosmium/test/t/thread/test_queue.cpp b/third_party/libosmium/test/t/thread/test_queue.cpp
new file mode 100644
index 00000000000..227642391b3
--- /dev/null
+++ b/third_party/libosmium/test/t/thread/test_queue.cpp
@@ -0,0 +1,20 @@
+#include "catch.hpp"
+
+#include <osmium/thread/queue.hpp>
+
+TEST_CASE("Basic use of thread-safe queue") {
+    osmium::thread::Queue<int> queue;
+    REQUIRE(queue.empty());
+    queue.push(22);
+    REQUIRE_FALSE(queue.empty());
+    REQUIRE(queue.size() == 1);
+    int value = 0;
+    queue.wait_and_pop(value);
+    REQUIRE(value == 22);
+    REQUIRE(queue.empty());
+}
+
+TEST_CASE("Queue can have max elements and can be named") {
+    osmium::thread::Queue<int> queue{100, "Queue of max size 100"};
+}
+
diff --git a/third_party/libosmium/test/t/thread/test_util.cpp b/third_party/libosmium/test/t/thread/test_util.cpp
index 419329e02d3..ecdd237ee13 100644
--- a/third_party/libosmium/test/t/thread/test_util.cpp
+++ b/third_party/libosmium/test/t/thread/test_util.cpp
@@ -1,9 +1,10 @@
-#include <catch.hpp>
-
-#include <stdexcept>
+#include "catch.hpp"
 
 #include <osmium/thread/util.hpp>
 
+#include <stdexcept>
+#include <type_traits>
+
 TEST_CASE("check_for_exception") {
     std::promise<int> p;
     auto f = p.get_future();
@@ -28,10 +29,32 @@ TEST_CASE("check_for_exception with exception") {
 
     try {
         throw std::runtime_error{"TEST"};
-    } catch(...) {
+    } catch (...) {
         p.set_exception(std::current_exception());
     }
 
     REQUIRE_THROWS_AS(osmium::thread::check_for_exception(f), const std::runtime_error&);
 }
 
+static_assert(std::is_nothrow_move_constructible<osmium::thread::thread_handler>::value, "thread_handler must have noexcept move constructor");
+
+TEST_CASE("empty thread_handler") {
+    osmium::thread::thread_handler th;
+}
+
+int foo;
+
+void test_func(int value) {
+    foo = value;
+}
+
+TEST_CASE("valid thread_handler") {
+    foo = 22;
+    test_func(17);
+    REQUIRE(foo == 17);
+    {
+        osmium::thread::thread_handler th{test_func, 5};
+    }
+    REQUIRE(foo == 5);
+}
+
diff --git a/third_party/libosmium/test/t/util/test_config.cpp b/third_party/libosmium/test/t/util/test_config.cpp
index 1f168d1638e..a062f73c717 100644
--- a/third_party/libosmium/test/t/util/test_config.cpp
+++ b/third_party/libosmium/test/t/util/test_config.cpp
@@ -1,75 +1,83 @@
 #include "catch.hpp"
 
 #include <cstdlib>
+#include <string>
 
-const char* env = nullptr;
-std::string name;
+namespace osmium {
 
-const char* fake_getenv(const char* env_var) {
-    name = env_var;
-    return env;
-}
+    namespace detail {
+
+        const char* env = nullptr;
+        std::string name;
+
+        inline const char* getenv_wrapper(const char* var) noexcept {
+            name = var;
+            return env;
+        }
+
+    } // namespace detail
 
-#define getenv fake_getenv
+} // namespace osmium
 
+#define OSMIUM_TEST_RUNNER
 #include <osmium/util/config.hpp>
 
 TEST_CASE("get_pool_threads") {
-    env = nullptr;
+    osmium::detail::env = nullptr;
     REQUIRE(osmium::config::get_pool_threads() == 0);
-    REQUIRE(name == "OSMIUM_POOL_THREADS");
-    env = "";
+    REQUIRE(osmium::detail::name == "OSMIUM_POOL_THREADS");
+    osmium::detail::env = "";
     REQUIRE(osmium::config::get_pool_threads() == 0);
-    env = "2";
+    osmium::detail::env = "2";
     REQUIRE(osmium::config::get_pool_threads() == 2);
 }
 
 TEST_CASE("use_pool_threads_for_pbf_parsing") {
-    env = nullptr;
+    osmium::detail::env = nullptr;
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
-    REQUIRE(name == "OSMIUM_USE_POOL_THREADS_FOR_PBF_PARSING");
-    env = "";
+    REQUIRE(osmium::detail::name == "OSMIUM_USE_POOL_THREADS_FOR_PBF_PARSING");
+    osmium::detail::env = "";
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
 
-    env = "off";
+    osmium::detail::env = "off";
     REQUIRE_FALSE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "OFF";
+    osmium::detail::env = "OFF";
     REQUIRE_FALSE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "false";
+    osmium::detail::env = "false";
     REQUIRE_FALSE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "no";
+    osmium::detail::env = "no";
     REQUIRE_FALSE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "No";
+    osmium::detail::env = "No";
     REQUIRE_FALSE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "0";
+    osmium::detail::env = "0";
     REQUIRE_FALSE(osmium::config::use_pool_threads_for_pbf_parsing());
 
-    env = "on";
+    osmium::detail::env = "on";
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "ON";
+    osmium::detail::env = "ON";
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "true";
+    osmium::detail::env = "true";
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "yes";
+    osmium::detail::env = "yes";
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "Yes";
+    osmium::detail::env = "Yes";
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
-    env = "1";
+    osmium::detail::env = "1";
     REQUIRE(osmium::config::use_pool_threads_for_pbf_parsing());
 }
 
 TEST_CASE("get_max_queue_size") {
-    env = nullptr;
+    osmium::detail::env = nullptr;
     REQUIRE(osmium::config::get_max_queue_size("NAME", 0) == 0);
-    REQUIRE(name == "OSMIUM_MAX_NAME_QUEUE_SIZE");
+    REQUIRE(osmium::detail::name == "OSMIUM_MAX_NAME_QUEUE_SIZE");
 
     REQUIRE(osmium::config::get_max_queue_size("NAME", 7) == 7);
 
-    env = "";
+    osmium::detail::env = "";
     REQUIRE(osmium::config::get_max_queue_size("NAME", 7) == 7);
-    env = "0";
+    osmium::detail::env = "0";
     REQUIRE(osmium::config::get_max_queue_size("NAME", 7) == 7);
-    env = "3";
+    osmium::detail::env = "3";
     REQUIRE(osmium::config::get_max_queue_size("NAME", 7) == 3);
 }
 
diff --git a/third_party/libosmium/test/t/util/test_delta.cpp b/third_party/libosmium/test/t/util/test_delta.cpp
index f6f2a548437..88c52daf795 100644
--- a/third_party/libosmium/test/t/util/test_delta.cpp
+++ b/third_party/libosmium/test/t/util/test_delta.cpp
@@ -1,12 +1,12 @@
 #include "catch.hpp"
 
+#include <osmium/util/delta.hpp>
+
 #include <cstdint>
 #include <vector>
 
-#include <osmium/util/delta.hpp>
-
 TEST_CASE("delta encode int") {
-    osmium::util::DeltaEncode<int> x;
+    osmium::DeltaEncode<int> x;
 
     REQUIRE(x.update(17) == 17);
     REQUIRE(x.value() == 17);
@@ -19,7 +19,7 @@ TEST_CASE("delta encode int") {
 }
 
 TEST_CASE("delta encode int with int32") {
-    osmium::util::DeltaEncode<int, int32_t> x;
+    osmium::DeltaEncode<int, int32_t> x;
 
     REQUIRE(x.update(17) == 17);
     REQUIRE(x.value() == 17);
@@ -32,7 +32,7 @@ TEST_CASE("delta encode int with int32") {
 }
 
 TEST_CASE("delta decode int") {
-    osmium::util::DeltaDecode<int> x;
+    osmium::DeltaDecode<int> x;
 
     REQUIRE(x.update(17) == 17);
     REQUIRE(x.update(10) == 27);
@@ -42,7 +42,7 @@ TEST_CASE("delta decode int") {
 }
 
 TEST_CASE("delta decode int with int32") {
-    osmium::util::DeltaDecode<int, int32_t> x;
+    osmium::DeltaDecode<int, int32_t> x;
 
     REQUIRE(x.update(17) == 17);
     REQUIRE(x.update(10) == 27);
@@ -52,7 +52,7 @@ TEST_CASE("delta decode int with int32") {
 }
 
 TEST_CASE("delta encode unsigned int") {
-    osmium::util::DeltaEncode<unsigned int> x;
+    osmium::DeltaEncode<unsigned int> x;
 
     REQUIRE(x.update(17) == 17);
     REQUIRE(x.update(10) == -7);
@@ -60,7 +60,7 @@ TEST_CASE("delta encode unsigned int") {
 }
 
 TEST_CASE("delta decode unsigned int") {
-    osmium::util::DeltaDecode<unsigned int> x;
+    osmium::DeltaDecode<unsigned int> x;
 
     REQUIRE(x.update(17) == 17);
     REQUIRE(x.update(10) == 27);
@@ -70,14 +70,16 @@ TEST_CASE("delta decode unsigned int") {
 TEST_CASE("delta encode and decode") {
     const std::vector<int> a = { 5, -9, 22, 13, 0, 23 };
 
-    osmium::util::DeltaEncode<int, int> de;
+    osmium::DeltaEncode<int, int> de;
     std::vector<int> b;
+    b.reserve(a.size());
     for (int x : a) {
         b.push_back(de.update(x));
     }
 
-    osmium::util::DeltaDecode<int, int> dd;
+    osmium::DeltaDecode<int, int> dd;
     std::vector<int> c;
+    c.reserve(b.size());
     for (int x : b) {
         c.push_back(dd.update(x));
     }
diff --git a/third_party/libosmium/test/t/util/test_double.cpp b/third_party/libosmium/test/t/util/test_double.cpp
index 3ffaa93f8ec..87c78d016bd 100644
--- a/third_party/libosmium/test/t/util/test_double.cpp
+++ b/third_party/libosmium/test/t/util/test_double.cpp
@@ -4,27 +4,27 @@
 
 TEST_CASE("Check double2string function") {
     std::string s1;
-    osmium::util::double2string(s1, 1.123, 7);
+    osmium::double2string(s1, 1.123, 7);
     REQUIRE(s1 == "1.123");
 
     std::string s2;
-    osmium::util::double2string(s2, 1.000, 7);
+    osmium::double2string(s2, 1.000, 7);
     REQUIRE(s2 == "1");
 
     std::string s3;
-    osmium::util::double2string(s3, 0.0, 7);
+    osmium::double2string(s3, 0.0, 7);
     REQUIRE(s3 == "0");
 
     std::string s4;
-    osmium::util::double2string(s4, 0.020, 7);
+    osmium::double2string(s4, 0.020, 7);
     REQUIRE(s4 == "0.02");
 
     std::string s5;
-    osmium::util::double2string(s5, -0.020, 7);
+    osmium::double2string(s5, -0.020, 7);
     REQUIRE(s5 == "-0.02");
 
     std::string s6;
-    osmium::util::double2string(s6, -0.0, 7);
+    osmium::double2string(s6, -0.0, 7);
     REQUIRE(s6 == "-0");
 }
 
diff --git a/third_party/libosmium/test/t/util/test_file.cpp b/third_party/libosmium/test/t/util/test_file.cpp
index a5d65ce6a1a..71cc2f3c339 100644
--- a/third_party/libosmium/test/t/util/test_file.cpp
+++ b/third_party/libosmium/test/t/util/test_file.cpp
@@ -1,4 +1,5 @@
 #include "catch.hpp"
+
 #include "utils.hpp"
 
 #include <osmium/io/detail/read_write.hpp>
@@ -8,44 +9,44 @@ TEST_CASE("file_size(int) and file_offset() of known file") {
     std::string file_name{with_data_dir("t/util/known_file_size")};
     const int fd = osmium::io::detail::open_for_reading(file_name);
     REQUIRE(fd > 0);
-    REQUIRE(osmium::util::file_size(fd) == 22);
-    REQUIRE(osmium::util::file_offset(fd) == 0);
-    REQUIRE_FALSE(osmium::util::isatty(fd));
+    REQUIRE(osmium::file_size(fd) == 22);
+    REQUIRE(osmium::file_offset(fd) == 0);
+    REQUIRE_FALSE(osmium::isatty(fd));
 }
 
 TEST_CASE("file_size(std::string) of known file") {
     std::string file_name{with_data_dir("t/util/known_file_size")};
-    REQUIRE(osmium::util::file_size(file_name) == 22);
+    REQUIRE(osmium::file_size(file_name) == 22);
 }
 
 TEST_CASE("file_size(const char*) of known file") {
     std::string file_name{with_data_dir("t/util/known_file_size")};
-    REQUIRE(osmium::util::file_size(file_name.c_str()) == 22);
+    REQUIRE(osmium::file_size(file_name.c_str()) == 22);
 }
 
 TEST_CASE("file_size() with illegal fd should throw") {
-    REQUIRE_THROWS_AS(osmium::util::file_size(-1), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::file_size(-1), const std::system_error&);
 }
 
 TEST_CASE("file_size() with unused fd should throw") {
     // its unlikely that fd 1000 is open...
-    REQUIRE_THROWS_AS(osmium::util::file_size(1000), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::file_size(1000), const std::system_error&);
 }
 
 TEST_CASE("file_size() of unknown file should throw") {
-    REQUIRE_THROWS_AS(osmium::util::file_size("unknown file"), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::file_size("unknown file"), const std::system_error&);
 }
 
 TEST_CASE("resize_file() with illegal fd should throw") {
-    REQUIRE_THROWS_AS(osmium::util::resize_file(-1, 10), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::resize_file(-1, 10), const std::system_error&);
 }
 
 TEST_CASE("resize_file() with unused fd should throw") {
     // its unlikely that fd 1000 is open...
-    REQUIRE_THROWS_AS(osmium::util::resize_file(1000, 10), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::resize_file(1000, 10), const std::system_error&);
 }
 
 TEST_CASE("get_pagesize()") {
-    REQUIRE(osmium::util::get_pagesize() > 0);
+    REQUIRE(osmium::get_pagesize() > 0);
 }
 
diff --git a/third_party/libosmium/test/t/util/test_memory.cpp b/third_party/libosmium/test/t/util/test_memory.cpp
index d1abc597ddd..fe3a309b83f 100644
--- a/third_party/libosmium/test/t/util/test_memory.cpp
+++ b/third_party/libosmium/test/t/util/test_memory.cpp
@@ -1,4 +1,3 @@
-
 #include "catch.hpp"
 
 #include <osmium/util/memory.hpp>
@@ -25,7 +24,7 @@ TEST_CASE("Check memory usage") {
 
     osmium::MemoryUsage m3;
     REQUIRE(m3.current() > 1);
-    REQUIRE(m3.current() < m3.peak());
+    REQUIRE(m3.current() <= m3.peak());
     REQUIRE(m3.peak() >= m1.peak() + size_in_mbytes);
 # endif
 #else
diff --git a/third_party/libosmium/test/t/util/test_memory_mapping.cpp b/third_party/libosmium/test/t/util/test_memory_mapping.cpp
index 7330aaf6f30..52e95a1db4b 100644
--- a/third_party/libosmium/test/t/util/test_memory_mapping.cpp
+++ b/third_party/libosmium/test/t/util/test_memory_mapping.cpp
@@ -1,12 +1,12 @@
 #include "catch.hpp"
 
+#include <osmium/util/file.hpp>
+#include <osmium/util/memory_mapping.hpp>
+
 #include <cstdlib>
 #include <limits>
 #include <utility>
 
-#include <osmium/util/file.hpp>
-#include <osmium/util/memory_mapping.hpp>
-
 #if defined(_MSC_VER) || (defined(__GNUC__) && defined(_WIN32))
 #include "win_mkstemp.hpp"
 #endif
@@ -14,7 +14,7 @@
 static const size_t huge = std::numeric_limits<size_t>::max();
 
 TEST_CASE("Anonymous mapping: simple memory mapping should work") {
-    osmium::util::MemoryMapping mapping{1000, osmium::util::MemoryMapping::mapping_mode::write_private};
+    osmium::MemoryMapping mapping{1000, osmium::MemoryMapping::mapping_mode::write_private};
     REQUIRE(mapping.get_addr() != nullptr);
 
     REQUIRE(mapping.size() >= 1000);
@@ -33,22 +33,22 @@ TEST_CASE("Anonymous mapping: simple memory mapping should work") {
 }
 
 TEST_CASE("Anonymous mapping: memory mapping of zero length should result in memory mapping of pagesize length") {
-    osmium::util::MemoryMapping mapping{0, osmium::util::MemoryMapping::mapping_mode::write_private};
-    REQUIRE(mapping.size() == osmium::util::get_pagesize());
+    osmium::MemoryMapping mapping{0, osmium::MemoryMapping::mapping_mode::write_private};
+    REQUIRE(mapping.size() == osmium::get_pagesize());
 }
 
 TEST_CASE("Anonymous mapping: moving a memory mapping should work") {
-    osmium::util::MemoryMapping mapping1{1000, osmium::util::MemoryMapping::mapping_mode::write_private};
-    int* addr1 = mapping1.get_addr<int>();
+    osmium::MemoryMapping mapping1{1000, osmium::MemoryMapping::mapping_mode::write_private};
+    auto* addr1 = mapping1.get_addr<int>();
     *addr1 = 42;
 
     REQUIRE(!!mapping1);
-    osmium::util::MemoryMapping mapping2{std::move(mapping1)};
+    osmium::MemoryMapping mapping2{std::move(mapping1)};
     REQUIRE(!!mapping2);
-    REQUIRE(!mapping1);
+    REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
     mapping1.unmap();
 
-    int* addr2 = mapping2.get_addr<int>();
+    const auto* addr2 = mapping2.get_addr<int>();
     REQUIRE(*addr2 == 42);
 
     mapping2.unmap();
@@ -56,20 +56,20 @@ TEST_CASE("Anonymous mapping: moving a memory mapping should work") {
 }
 
 TEST_CASE("Anonymous mapping: move assignment should work") {
-    osmium::util::MemoryMapping mapping1{1000, osmium::util::MemoryMapping::mapping_mode::write_private};
-    osmium::util::MemoryMapping mapping2{1000, osmium::util::MemoryMapping::mapping_mode::write_private};
+    osmium::MemoryMapping mapping1{1000, osmium::MemoryMapping::mapping_mode::write_private};
+    osmium::MemoryMapping mapping2{1000, osmium::MemoryMapping::mapping_mode::write_private};
 
     REQUIRE(!!mapping1);
     REQUIRE(!!mapping2);
 
-    int* addr1 = mapping1.get_addr<int>();
+    auto* addr1 = mapping1.get_addr<int>();
     *addr1 = 42;
 
     mapping2 = std::move(mapping1);
     REQUIRE(!!mapping2);
-    REQUIRE(!mapping1);
+    REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
 
-    int* addr2 = mapping2.get_addr<int>();
+    const auto* addr2 = mapping2.get_addr<int>();
     REQUIRE(*addr2 == 42);
 
     mapping2.unmap();
@@ -78,34 +78,34 @@ TEST_CASE("Anonymous mapping: move assignment should work") {
 
 #ifdef __linux__
 TEST_CASE("Anonymous mapping: remapping to larger size should work") {
-    osmium::util::MemoryMapping mapping{1000, osmium::util::MemoryMapping::mapping_mode::write_private};
+    osmium::MemoryMapping mapping{1000, osmium::MemoryMapping::mapping_mode::write_private};
     REQUIRE(mapping.size() >= 1000);
 
     const size_t size1 = mapping.size();
 
-    int* addr1 = mapping.get_addr<int>();
+    auto* addr1 = mapping.get_addr<int>();
     *addr1 = 42;
 
     mapping.resize(8000);
     REQUIRE(mapping.size() > size1);
 
-    int* addr2 = mapping.get_addr<int>();
+    const auto* addr2 = mapping.get_addr<int>();
     REQUIRE(*addr2 == 42);
 }
 
 TEST_CASE("Anonymous mapping: remapping to smaller size should work") {
-    osmium::util::MemoryMapping mapping{8000, osmium::util::MemoryMapping::mapping_mode::write_private};
+    osmium::MemoryMapping mapping{8000, osmium::MemoryMapping::mapping_mode::write_private};
     REQUIRE(mapping.size() >= 1000);
 
     const size_t size1 = mapping.size();
 
-    int* addr1 = mapping.get_addr<int>();
+    auto* addr1 = mapping.get_addr<int>();
     *addr1 = 42;
 
     mapping.resize(500);
     REQUIRE(mapping.size() < size1);
 
-    int* addr2 = mapping.get_addr<int>();
+    const auto* addr2 = mapping.get_addr<int>();
     REQUIRE(*addr2 == 42);
 }
 #endif
@@ -115,10 +115,10 @@ TEST_CASE("File-based mapping: writing to a mapped file should work") {
     const int fd = mkstemp(filename);
     REQUIRE(fd > 0);
 
-    osmium::util::resize_file(fd, 100);
+    osmium::resize_file(fd, 100);
 
     {
-        osmium::util::MemoryMapping mapping{100, osmium::util::MemoryMapping::mapping_mode::write_shared, fd};
+        osmium::MemoryMapping mapping{100, osmium::MemoryMapping::mapping_mode::write_shared, fd};
         REQUIRE(mapping.writable());
 
         REQUIRE(!!mapping);
@@ -129,11 +129,11 @@ TEST_CASE("File-based mapping: writing to a mapped file should work") {
         mapping.unmap();
     }
 
-    REQUIRE(osmium::util::file_size(fd) == 100);
+    REQUIRE(osmium::file_size(fd) == 100);
 
     {
-        osmium::util::MemoryMapping mapping{100, osmium::util::MemoryMapping::mapping_mode::readonly, fd};
-        REQUIRE(!mapping.writable());
+        osmium::MemoryMapping mapping{100, osmium::MemoryMapping::mapping_mode::readonly, fd};
+        REQUIRE_FALSE(mapping.writable());
 
         REQUIRE(!!mapping);
         REQUIRE(mapping.size() >= 100);
@@ -152,7 +152,7 @@ TEST_CASE("File-based mapping: Reading from a zero-sized mapped file should work
     REQUIRE(fd > 0);
 
     {
-        osmium::util::MemoryMapping mapping{0, osmium::util::MemoryMapping::mapping_mode::readonly, fd};
+        osmium::MemoryMapping mapping{0, osmium::MemoryMapping::mapping_mode::readonly, fd};
         REQUIRE(mapping.size() > 0);
         mapping.unmap();
     }
@@ -166,10 +166,10 @@ TEST_CASE("File-based mapping: writing to a privately mapped file should work")
     const int fd = mkstemp(filename);
     REQUIRE(fd > 0);
 
-    osmium::util::resize_file(fd, 100);
+    osmium::resize_file(fd, 100);
 
     {
-        osmium::util::MemoryMapping mapping{100, osmium::util::MemoryMapping::mapping_mode::write_private, fd};
+        osmium::MemoryMapping mapping{100, osmium::MemoryMapping::mapping_mode::write_private, fd};
         REQUIRE(mapping.writable());
 
         REQUIRE(!!mapping);
@@ -180,11 +180,11 @@ TEST_CASE("File-based mapping: writing to a privately mapped file should work")
         mapping.unmap();
     }
 
-    REQUIRE(osmium::util::file_size(fd) == 100);
+    REQUIRE(osmium::file_size(fd) == 100);
 
     {
-        osmium::util::MemoryMapping mapping{100, osmium::util::MemoryMapping::mapping_mode::readonly, fd};
-        REQUIRE(!mapping.writable());
+        osmium::MemoryMapping mapping{100, osmium::MemoryMapping::mapping_mode::readonly, fd};
+        REQUIRE_FALSE(mapping.writable());
 
         REQUIRE(!!mapping);
         REQUIRE(mapping.size() >= 100);
@@ -202,18 +202,18 @@ TEST_CASE("File-based mapping: remapping to larger size should work") {
     const int fd = mkstemp(filename);
     REQUIRE(fd > 0);
 
-    osmium::util::MemoryMapping mapping{100, osmium::util::MemoryMapping::mapping_mode::write_shared, fd};
+    osmium::MemoryMapping mapping{100, osmium::MemoryMapping::mapping_mode::write_shared, fd};
     REQUIRE(mapping.size() >= 100);
     const size_t size1 = mapping.size();
 
-    int* addr1 = mapping.get_addr<int>();
+    auto* addr1 = mapping.get_addr<int>();
     *addr1 = 42;
 
     mapping.resize(8000);
     REQUIRE(mapping.size() >= 8000);
     REQUIRE(mapping.size() > size1);
 
-    int* addr2 = mapping.get_addr<int>();
+    const auto* addr2 = mapping.get_addr<int>();
     REQUIRE(*addr2 == 42);
 
     mapping.unmap();
@@ -228,18 +228,18 @@ TEST_CASE("File-based mapping: remapping to smaller size should work") {
     REQUIRE(fd > 0);
 
     {
-        osmium::util::MemoryMapping mapping{8000, osmium::util::MemoryMapping::mapping_mode::write_shared, fd};
+        osmium::MemoryMapping mapping{8000, osmium::MemoryMapping::mapping_mode::write_shared, fd};
         REQUIRE(mapping.size() >= 8000);
         const size_t size1 = mapping.size();
 
-        int* addr1 = mapping.get_addr<int>();
+        auto* addr1 = mapping.get_addr<int>();
         *addr1 = 42;
 
         mapping.resize(50);
         REQUIRE(mapping.size() >= 50);
         REQUIRE(mapping.size() < size1);
 
-        int* addr2 = mapping.get_addr<int>();
+        const auto* addr2 = mapping.get_addr<int>();
         REQUIRE(*addr2 == 42);
     }
 
@@ -248,7 +248,7 @@ TEST_CASE("File-based mapping: remapping to smaller size should work") {
 }
 
 TEST_CASE("Typed anonymous mapping: simple memory mapping should work") {
-    osmium::util::TypedMemoryMapping<uint32_t> mapping{1000};
+    osmium::TypedMemoryMapping<uint32_t> mapping{1000};
     volatile uint32_t* addr = mapping.begin();
 
     REQUIRE(mapping.writable());
@@ -263,14 +263,14 @@ TEST_CASE("Typed anonymous mapping: simple memory mapping should work") {
 }
 
 TEST_CASE("Typed anonymous mapping: moving a memory mapping should work") {
-    osmium::util::TypedMemoryMapping<uint32_t> mapping1{1000};
+    osmium::TypedMemoryMapping<uint32_t> mapping1{1000};
     uint32_t* addr1 = mapping1.begin();
     *addr1 = 42;
 
     REQUIRE(!!mapping1);
-    osmium::util::TypedMemoryMapping<uint32_t> mapping2{std::move(mapping1)};
+    osmium::TypedMemoryMapping<uint32_t> mapping2{std::move(mapping1)};
     REQUIRE(!!mapping2);
-    REQUIRE(!mapping1);
+    REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
     mapping1.unmap();
 
     const auto addr2 = mapping2.begin();
@@ -281,8 +281,8 @@ TEST_CASE("Typed anonymous mapping: moving a memory mapping should work") {
 }
 
 TEST_CASE("Typed anonymous mapping: move assignment should work") {
-    osmium::util::TypedMemoryMapping<uint32_t> mapping1{1000};
-    osmium::util::TypedMemoryMapping<uint32_t> mapping2{1000};
+    osmium::TypedMemoryMapping<uint32_t> mapping1{1000};
+    osmium::TypedMemoryMapping<uint32_t> mapping2{1000};
 
     REQUIRE(!!mapping1);
     REQUIRE(!!mapping2);
@@ -292,7 +292,7 @@ TEST_CASE("Typed anonymous mapping: move assignment should work") {
 
     mapping2 = std::move(mapping1);
     REQUIRE(!!mapping2);
-    REQUIRE(!mapping1);
+    REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
 
     const auto addr2 = mapping2.begin();
     REQUIRE(*addr2 == 42);
@@ -303,7 +303,7 @@ TEST_CASE("Typed anonymous mapping: move assignment should work") {
 
 #ifdef __linux__
 TEST_CASE("Typed anonymous mapping: remapping to larger size should work") {
-    osmium::util::TypedMemoryMapping<uint32_t> mapping{1000};
+    osmium::TypedMemoryMapping<uint32_t> mapping{1000};
     REQUIRE(mapping.size() >= 1000);
 
     auto addr1 = mapping.begin();
@@ -316,7 +316,7 @@ TEST_CASE("Typed anonymous mapping: remapping to larger size should work") {
 }
 
 TEST_CASE("Typed anonymous mapping: remapping to smaller size should work") {
-    osmium::util::TypedMemoryMapping<uint32_t> mapping{8000};
+    osmium::TypedMemoryMapping<uint32_t> mapping{8000};
     REQUIRE(mapping.size() >= 8000);
 
     auto addr1 = mapping.begin();
@@ -334,10 +334,10 @@ TEST_CASE("Typed file-based mapping: writing to a mapped file should work") {
     const int fd = mkstemp(filename);
     REQUIRE(fd > 0);
 
-    osmium::util::resize_file(fd, 100);
+    osmium::resize_file(fd, 100);
 
     {
-        osmium::util::TypedMemoryMapping<uint32_t> mapping{100, osmium::util::MemoryMapping::mapping_mode::write_shared, fd};
+        osmium::TypedMemoryMapping<uint32_t> mapping{100, osmium::MemoryMapping::mapping_mode::write_shared, fd};
         REQUIRE(mapping.writable());
 
         REQUIRE(!!mapping);
@@ -349,8 +349,8 @@ TEST_CASE("Typed file-based mapping: writing to a mapped file should work") {
     }
 
     {
-        osmium::util::TypedMemoryMapping<uint32_t> mapping{100, osmium::util::MemoryMapping::mapping_mode::readonly, fd};
-        REQUIRE(!mapping.writable());
+        osmium::TypedMemoryMapping<uint32_t> mapping{100, osmium::MemoryMapping::mapping_mode::readonly, fd};
+        REQUIRE_FALSE(mapping.writable());
 
         REQUIRE(!!mapping);
         REQUIRE(mapping.size() >= 100);
@@ -364,7 +364,7 @@ TEST_CASE("Typed file-based mapping: writing to a mapped file should work") {
 }
 
 TEST_CASE("Anonymous memory mapping class: simple memory mapping should work") {
-    osmium::util::AnonymousMemoryMapping mapping{1000};
+    osmium::AnonymousMemoryMapping mapping{1000};
     REQUIRE(mapping.get_addr() != nullptr);
 
     volatile int* addr = mapping.get_addr<int>();
@@ -382,28 +382,28 @@ TEST_CASE("Anonymous memory mapping class: simple memory mapping should work") {
 
 #ifdef __linux__
 TEST_CASE("Anonymous memory mapping class: remapping to larger size should work") {
-    osmium::util::AnonymousMemoryMapping mapping{1000};
+    osmium::AnonymousMemoryMapping mapping{1000};
     REQUIRE(mapping.size() >= 1000);
 
-    int* addr1 = mapping.get_addr<int>();
+    auto* addr1 = mapping.get_addr<int>();
     *addr1 = 42;
 
     mapping.resize(2000);
 
-    const int* addr2 = mapping.get_addr<int>();
+    const auto* addr2 = mapping.get_addr<int>();
     REQUIRE(*addr2 == 42);
 }
 
 TEST_CASE("Anonymous memory mapping class: remapping to smaller size should work") {
-    osmium::util::AnonymousMemoryMapping mapping{2000};
+    osmium::AnonymousMemoryMapping mapping{2000};
     REQUIRE(mapping.size() >= 2000);
 
-    int* addr1 = mapping.get_addr<int>();
+    auto* addr1 = mapping.get_addr<int>();
     *addr1 = 42;
 
     mapping.resize(500);
 
-    const int* addr2 = mapping.get_addr<int>();
+    const auto* addr2 = mapping.get_addr<int>();
     REQUIRE(*addr2 == 42);
 }
 #endif
diff --git a/third_party/libosmium/test/t/util/test_minmax.cpp b/third_party/libosmium/test/t/util/test_minmax.cpp
index f84d4e4ba15..f9ca637deb0 100644
--- a/third_party/libosmium/test/t/util/test_minmax.cpp
+++ b/third_party/libosmium/test/t/util/test_minmax.cpp
@@ -1,7 +1,7 @@
 #include "catch.hpp"
 
-#include <osmium/util/minmax.hpp>
 #include <osmium/osm/timestamp.hpp>
+#include <osmium/util/minmax.hpp>
 
 TEST_CASE("min_op numeric") {
     osmium::min_op<int> x;
diff --git a/third_party/libosmium/test/t/util/test_misc.cpp b/third_party/libosmium/test/t/util/test_misc.cpp
new file mode 100644
index 00000000000..ef5be02d43e
--- /dev/null
+++ b/third_party/libosmium/test/t/util/test_misc.cpp
@@ -0,0 +1,68 @@
+#include "catch.hpp"
+
+#include <osmium/util/misc.hpp>
+
+template <typename T>
+void test_conv() {
+    REQUIRE(osmium::detail::str_to_int<T>("0") == 0);
+    REQUIRE(osmium::detail::str_to_int<T>("1") == 1);
+    REQUIRE(osmium::detail::str_to_int<T>("9") == 9);
+    REQUIRE(osmium::detail::str_to_int<T>("10") == 10);
+    REQUIRE(osmium::detail::str_to_int<T>("44") == 44);
+    REQUIRE(osmium::detail::str_to_int<T>("45") == 45);
+    REQUIRE(osmium::detail::str_to_int<T>("  123") == 123);
+
+    REQUIRE(osmium::detail::str_to_int<T>("-1") == 0);
+    REQUIRE(osmium::detail::str_to_int<T>("-100") == 0);
+    REQUIRE(osmium::detail::str_to_int<T>("1 ") == 0);
+    REQUIRE(osmium::detail::str_to_int<T>("x1") == 0);
+    REQUIRE(osmium::detail::str_to_int<T>("1x") == 0);
+    REQUIRE(osmium::detail::str_to_int<T>("2 3") == 0);
+    REQUIRE(osmium::detail::str_to_int<T>("9999999999999999999999") == 0);
+}
+
+TEST_CASE("string to integer conversion") {
+    test_conv<int>();
+    test_conv<unsigned int>();
+
+    test_conv<int8_t>();
+    REQUIRE(osmium::detail::str_to_int<int8_t>("126") == 126);
+    REQUIRE(osmium::detail::str_to_int<int8_t>("127") == 0);
+    REQUIRE(osmium::detail::str_to_int<int8_t>("128") == 0);
+
+    test_conv<uint8_t>();
+    REQUIRE(osmium::detail::str_to_int<uint8_t>("254") == 254);
+    REQUIRE(osmium::detail::str_to_int<uint8_t>("255") == 0);
+    REQUIRE(osmium::detail::str_to_int<uint8_t>("256") == 0);
+
+    test_conv<int16_t>();
+    REQUIRE(osmium::detail::str_to_int<int16_t>("32766") == 32766);
+    REQUIRE(osmium::detail::str_to_int<int16_t>("32767") == 0);
+    REQUIRE(osmium::detail::str_to_int<int16_t>("32768") == 0);
+
+    test_conv<uint16_t>();
+    REQUIRE(osmium::detail::str_to_int<uint16_t>("65534") == 65534);
+    REQUIRE(osmium::detail::str_to_int<uint16_t>("65535") == 0);
+    REQUIRE(osmium::detail::str_to_int<uint16_t>("65536") == 0);
+
+    test_conv<int32_t>();
+    REQUIRE(osmium::detail::str_to_int<int32_t>("2147483646") == 2147483646ll);
+    REQUIRE(osmium::detail::str_to_int<int32_t>("2147483647") == 0);
+    REQUIRE(osmium::detail::str_to_int<int32_t>("2147483648") == 0);
+
+    test_conv<uint32_t>();
+    REQUIRE(osmium::detail::str_to_int<uint32_t>("4294967294") == 4294967294ull);
+    REQUIRE(osmium::detail::str_to_int<uint32_t>("4294967295") == 0);
+    REQUIRE(osmium::detail::str_to_int<uint32_t>("4294967296") == 0);
+
+    test_conv<int64_t>();
+    REQUIRE(osmium::detail::str_to_int<int64_t>("9223372036854775806") == 9223372036854775806ll);
+    REQUIRE(osmium::detail::str_to_int<int64_t>("9223372036854775807") == 0);
+    REQUIRE(osmium::detail::str_to_int<int64_t>("9223372036854775808") == 0);
+
+    test_conv<uint64_t>();
+    REQUIRE(osmium::detail::str_to_int<uint64_t>("9223372036854775806") == 9223372036854775806ull);
+    REQUIRE(osmium::detail::str_to_int<uint64_t>("9223372036854775807") == 0);
+    REQUIRE(osmium::detail::str_to_int<uint64_t>("9223372036854775808") == 0);
+}
+
diff --git a/third_party/libosmium/test/t/util/test_options.cpp b/third_party/libosmium/test/t/util/test_options.cpp
index 618fa8949ab..30772692a1d 100644
--- a/third_party/libosmium/test/t/util/test_options.cpp
+++ b/third_party/libosmium/test/t/util/test_options.cpp
@@ -3,11 +3,11 @@
 #include <osmium/util/options.hpp>
 
 TEST_CASE("Set a single option value from string") {
-    osmium::util::Options o;
+    osmium::Options o;
 
     o.set("foo", "bar");
     REQUIRE("bar" == o.get("foo"));
-    REQUIRE("" == o.get("empty"));
+    REQUIRE(o.get("empty").empty());
     REQUIRE("default" == o.get("empty", "default"));
 
     REQUIRE_FALSE(o.is_true("foo"));
@@ -20,13 +20,13 @@ TEST_CASE("Set a single option value from string") {
 }
 
 TEST_CASE("Set option values from booleans") {
-    osmium::util::Options o;
+    osmium::Options o;
 
     o.set("t", true);
     o.set("f", false);
     REQUIRE("true" == o.get("t"));
     REQUIRE("false" == o.get("f"));
-    REQUIRE("" == o.get("empty"));
+    REQUIRE(o.get("empty").empty());
 
     REQUIRE(o.is_true("t"));
     REQUIRE_FALSE(o.is_true("f"));
@@ -38,7 +38,7 @@ TEST_CASE("Set option values from booleans") {
 }
 
 TEST_CASE("Set option value from string with equal sign") {
-    osmium::util::Options o;
+    osmium::Options o;
 
     o.set("foo=bar");
     REQUIRE("bar" == o.get("foo"));
@@ -46,7 +46,7 @@ TEST_CASE("Set option value from string with equal sign") {
 }
 
 TEST_CASE("Set option value from string without equal sign") {
-    osmium::util::Options o;
+    osmium::Options o;
 
     o.set("foo");
     REQUIRE("true" == o.get("foo"));
@@ -58,7 +58,7 @@ TEST_CASE("Set option value from string without equal sign") {
 }
 
 TEST_CASE("Options with initializer list") {
-    osmium::util::Options o{{ "foo", "true" }, { "bar", "17" }};
+    osmium::Options o{{ "foo", "true" }, { "bar", "17" }};
 
     REQUIRE(o.get("foo") == "true");
     REQUIRE(o.get("bar") == "17");
@@ -79,7 +79,7 @@ TEST_CASE("Options with initializer list") {
 }
 
 TEST_CASE("Iterating over options") {
-    /*not const*/ osmium::util::Options o{{ "foo", "true" }, { "bar", "17" }};
+    /*not const*/ osmium::Options o{{ "foo", "true" }, { "bar", "17" }};
 
     auto it = o.begin();
     REQUIRE(it->first == "bar");
@@ -92,7 +92,7 @@ TEST_CASE("Iterating over options") {
 }
 
 TEST_CASE("Const iterating over options") {
-    const osmium::util::Options o{{ "foo", "true" }, { "bar", "17" }};
+    const osmium::Options o{{ "foo", "true" }, { "bar", "17" }};
 
     SECTION("begin/end") {
         auto it = o.begin();
diff --git a/third_party/libosmium/test/t/util/test_string.cpp b/third_party/libosmium/test/t/util/test_string.cpp
index 95e0e9a3588..a0aa76e50d6 100644
--- a/third_party/libosmium/test/t/util/test_string.cpp
+++ b/third_party/libosmium/test/t/util/test_string.cpp
@@ -67,7 +67,7 @@ TEST_CASE("split_string sep") {
 }
 
 TEST_CASE("split_string empty string") {
-    const std::string str{""};
+    const std::string str{};
     const std::vector<std::string> result;
 
     REQUIRE(result == osmium::split_string(str, ','));
diff --git a/third_party/libosmium/test/t/util/test_string_matcher.cpp b/third_party/libosmium/test/t/util/test_string_matcher.cpp
index 64b2f2806ba..2e2e3056a73 100644
--- a/third_party/libosmium/test/t/util/test_string_matcher.cpp
+++ b/third_party/libosmium/test/t/util/test_string_matcher.cpp
@@ -1,10 +1,10 @@
 #include "catch.hpp"
 
+#include <osmium/util/string_matcher.hpp>
+
 #include <sstream>
 #include <type_traits>
 
-#include <osmium/util/string_matcher.hpp>
-
 static_assert(std::is_default_constructible<osmium::StringMatcher>::value, "StringMatcher should be default constructible");
 static_assert(std::is_copy_constructible<osmium::StringMatcher>::value, "StringMatcher should be copy constructible");
 static_assert(std::is_move_constructible<osmium::StringMatcher>::value, "StringMatcher should be move constructible");
@@ -187,3 +187,35 @@ TEST_CASE("Construct StringMatcher") {
     REQUIRE(print(m) == "substring[foo]");
 }
 
+TEST_CASE("Copy construct StringMatcher") {
+    osmium::StringMatcher m1{"foo"};
+    osmium::StringMatcher m2{m1}; // NOLINT(performance-unnecessary-copy-initialization)
+
+    REQUIRE(print(m1) == "equal[foo]");
+    REQUIRE(print(m2) == "equal[foo]");
+}
+
+TEST_CASE("Copy assign StringMatcher") {
+    osmium::StringMatcher m1{"foo"};
+    osmium::StringMatcher m2{"bar"};
+    m2 = m1;
+
+    REQUIRE(print(m1) == "equal[foo]");
+    REQUIRE(print(m2) == "equal[foo]");
+}
+
+TEST_CASE("Move construct StringMatcher") {
+    osmium::StringMatcher m1{"foo"};
+    osmium::StringMatcher m2{std::move(m1)};
+
+    REQUIRE(print(m2) == "equal[foo]");
+}
+
+TEST_CASE("Move assign StringMatcher") {
+    osmium::StringMatcher m1{"foo"};
+    osmium::StringMatcher m2{"bar"};
+    m2 = std::move(m1);
+
+    REQUIRE(print(m2) == "equal[foo]");
+}
+
diff --git a/third_party/libosmium/test/t/util/test_timer_disabled.cpp b/third_party/libosmium/test/t/util/test_timer_disabled.cpp
index 2bf01ffd72b..c62ad34f030 100644
--- a/third_party/libosmium/test/t/util/test_timer_disabled.cpp
+++ b/third_party/libosmium/test/t/util/test_timer_disabled.cpp
@@ -1,10 +1,10 @@
 #include "catch.hpp"
 
+#include <osmium/util/timer.hpp>
+
 #include <chrono>
 #include <thread>
 
-#include <osmium/util/timer.hpp>
-
 TEST_CASE("timer") {
     osmium::Timer timer;
     timer.start();
diff --git a/third_party/protozero/.clang-tidy b/third_party/protozero/.clang-tidy
new file mode 100644
index 00000000000..1ba914c7c59
--- /dev/null
+++ b/third_party/protozero/.clang-tidy
@@ -0,0 +1,34 @@
+---
+Checks: '*,-cert-dcl21-cpp,-cert-err60-cpp,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-type-reinterpret-cast,-fuchsia-*,-google-runtime-references,-hicpp-no-array-decay'
+#
+#  Disabled checks:
+#
+#  cert-dcl21-cpp
+#    It is unclear whether this is still a good recommendation in modern C++.
+#
+#  cert-err60-cpp
+#    Reports std::runtime_error as broken which we can't do anything about.
+#
+#  cppcoreguidelines-pro-bounds-array-to-pointer-decay
+#    Limited use and many false positives including for all asserts.
+#
+#  cppcoreguidelines-pro-bounds-pointer-arithmetic
+#    This is a low-level library, it needs to do pointer arithmetic.
+#
+#  cppcoreguidelines-pro-type-reinterpret-cast
+#    This is a low-level library, it needs to do reinterpret-casts.
+#
+#  fuchsia-*
+#    Much too strict.
+#
+#  google-runtime-references
+#    This is just a matter of preference, and we can't change the interfaces
+#    now anyways.
+#
+#  hicpp-no-array-decay
+#    Limited use and many false positives including for all asserts.
+#
+WarningsAsErrors: '*'
+HeaderFilterRegex: '\/include\/'
+AnalyzeTemporaryDtors: false
+...
diff --git a/third_party/protozero/.gitattributes b/third_party/protozero/.gitattributes
new file mode 100644
index 00000000000..3503e2c4006
--- /dev/null
+++ b/third_party/protozero/.gitattributes
@@ -0,0 +1 @@
+*.pbf -text
diff --git a/third_party/protozero/.travis.yml b/third_party/protozero/.travis.yml
new file mode 100644
index 00000000000..891e59bba20
--- /dev/null
+++ b/third_party/protozero/.travis.yml
@@ -0,0 +1,178 @@
+#-----------------------------------------------------------------------------
+#
+#  Configuration for continuous integration service at travis-ci.org
+#
+#-----------------------------------------------------------------------------
+
+language: generic
+
+sudo: false
+
+dist: trusty
+
+#-----------------------------------------------------------------------------
+
+# Save common build configurations as shortcuts, so we can reference them later.
+addons_shortcuts:
+  addons_clang35: &clang35
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-3.5' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'clang-3.5' ]
+  addons_clang38: &clang38
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-3.8' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'clang-3.8' ]
+  addons_clang39: &clang39
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-3.9' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'clang-3.9' ]
+  addons_clang40: &clang40
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-4.0' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'clang-4.0' ]
+  addons_clang50: &clang50
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-5.0' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'clang-5.0', 'clang-tidy-5.0' ]
+  addons_gcc47: &gcc47
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'g++-4.7', 'gcc-4.7' ]
+  addons_gcc48: &gcc48
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'g++-4.8', 'gcc-4.8' ]
+  addons_gcc49: &gcc49
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'g++-4.9', 'gcc-4.9' ]
+  addons_gcc5: &gcc5
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'g++-5', 'gcc-5' ]
+  addons_gcc6: &gcc6
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libprotobuf-dev','protobuf-compiler', 'g++-6', 'gcc-6' ]
+
+#-----------------------------------------------------------------------------
+
+matrix:
+  include:
+    - os: linux
+      compiler: "clang-3.5"
+      env: BUILD='Debug' CC=clang-3.5 CXX=clang++-3.5
+      addons: *clang35
+    - os: linux
+      compiler: "clang-3.8"
+      env: BUILD='Debug' CC=clang-3.8 CXX=clang++-3.8
+      addons: *clang38
+    - os: linux
+      compiler: "clang-3.9"
+      env: BUILD='Debug' CC=clang-3.9 CXX=clang++-3.9
+      addons: *clang39
+    - os: linux
+      compiler: "clang-4.0"
+      env: BUILD='Debug' CC=clang-4.0 CXX=clang++-4.0
+      addons: *clang40
+    - os: linux
+      compiler: "clang-5.0"
+      env: BUILD='Debug' CC=clang-5.0 CXX=clang++-5.0
+           CLANG_TIDY=clang-tidy-5.0
+      addons: *clang50
+    - os: linux
+      compiler: "clang-5.0"
+      env: BUILD='Release' CC=clang-5.0 CXX=clang++-5.0
+      addons: *clang50
+    - os: linux
+      compiler: "clang-5.0"
+      env: BUILD='Debug' CC=clang-5.0 CXX=clang++-5.0
+           CXXFLAGS="-fsanitize=address,undefined,integer -fno-sanitize-recover=all -fno-omit-frame-pointer"
+           LDFLAGS="-fsanitize=address,undefined,integer"
+      # LSAN doesn't work on container-based system
+      sudo: required
+      addons: *clang50
+    - os: linux
+      compiler: "gcc-4.7"
+      env: BUILD='Debug' CC=gcc-4.7 CXX=g++-4.7
+      addons: *gcc47
+    - os: linux
+      compiler: "gcc-4.8"
+      env: BUILD='Debug' CC=gcc-4.8 CXX=g++-4.8
+      addons: *gcc48
+    - os: linux
+      compiler: "gcc-4.9"
+      env: BUILD='Debug' CC=gcc-4.9 CXX=g++-4.9
+           COVERAGE=gcov-4.9
+           CXXFLAGS="--coverage" LDFLAGS="--coverage"
+      addons: *gcc49
+    - os: linux
+      compiler: "gcc-5"
+      env: BUILD='Debug' CC=gcc-5 CXX=g++-5
+           CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=0"
+      addons: *gcc5
+    - os: linux
+      compiler: "gcc-5"
+      env: BUILD='Debug' CC=gcc-5 CXX=g++-5
+           CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=1"
+      addons: *gcc5
+    - os: linux
+      compiler: "gcc-6"
+      env: BUILD='Debug' CC=gcc-6 CXX=g++-6
+      addons: *gcc6
+    - os: linux
+      compiler: "gcc-6"
+      env: BUILD='Debug' CC=gcc-6 CXX=g++-6
+           PROTOZERO_DATA_VIEW=std::experimental::string_view
+      addons: *gcc6
+    - os: linux
+      compiler: "gcc-6"
+      env: BUILD='Release' CC=gcc-6 CXX=g++-6
+      addons: *gcc6
+    - os: osx
+      osx_image: xcode6.4
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode8.3
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode9.1
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode9.1
+      compiler: clang
+      env: BUILD='Release'
+
+#-----------------------------------------------------------------------------
+
+install:
+  - if [[ $(uname -s) == 'Darwin' ]]; then
+      brew update;
+      brew install protobuf;
+    fi
+
+script:
+  - mkdir build
+  - cd build
+  - cmake .. -LA -DCMAKE_BUILD_TYPE=${BUILD} -DPROTOZERO_DATA_VIEW=$PROTOZERO_DATA_VIEW -DCLANG_TIDY=$(which ${CLANG_TIDY})
+  - make VERBOSE=1
+  - ctest --output-on-failure
+  - if [ -n "${CLANG_TIDY}" ]; then make clang-tidy; fi
+  - |
+    if [ -n "${COVERAGE}" ]; then
+      which ${COVERAGE}
+      curl -S -f https://codecov.io/bash -o codecov
+      chmod +x codecov
+      ${COVERAGE} -p $(find test/ tools/ -name '*.o')
+      ./codecov -Z -f '*protozero*' -f '*tools*' -f '!*catch*' -X search
+    fi
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/protozero/CHANGELOG.md b/third_party/protozero/CHANGELOG.md
new file mode 100644
index 00000000000..d43f422b632
--- /dev/null
+++ b/third_party/protozero/CHANGELOG.md
@@ -0,0 +1,324 @@
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+
+## [unreleased] -
+
+### Added
+
+### Changed
+
+### Fixed
+
+
+## [1.6.2] - 2018-03-09
+
+### Changed
+
+- Update included catch.hpp to v1.12.0.
+- Move basic unit tests into their own directory (`test/unit`).
+- Improved clang-tidy config and fixed some code producing warnings.
+
+### Fixed
+
+- Buffer overflow in pbf-decoder tool.
+
+
+## [1.6.1] - 2017-11-16
+
+### Added
+
+- Document internal handling of varints.
+- Add aliases for fixed iterators, too.
+
+### Changed
+
+- The `const_fixed_iterator` is now a random access iterator making code
+  using it potentially more performant (for instance when using
+  `std::distance`)
+- Overloads `std::distance` for the varint and svarint iterators. This is
+  better than the workaround with the `rage_size` function used before.
+
+### Fixed
+
+- Rename `.proto` files in some tests to be unique. This solves a problem
+  when building with newer versions of the Google Protobuf library.
+- Floating point comparisons in tests are now always correctly done using
+  `Approx()`.
+
+
+## [1.6.0] - 2017-10-24
+
+### Added
+
+- Comparison functions (<, <=, >, >=) for `data_view`. Allows use in `std::map`
+  for instance.
+- Tool `pbf-decoder` for decoding raw messages. This has limited use for
+  normal users, but it can be used for fuzzing.
+
+### Changed
+
+- Protozero now uses CMake to build the tests etc. This does not affect
+  simple users of the library, but if you are using CMake yourself you might
+  want to use the `cmake/FindProtozero.cmake` module provided. The README
+  contains more information about build options.
+- Moved `data_view` class from `types.hpp` into its own header file
+  `data_view.hpp`.
+- Implementation of the `const_fixed_iterator` to use only a single pointer
+  instead of two.
+- Made `operator==` and `operator!=` on `data_view` constexpr.
+- The `pbf_reader` constructor taking a `std::pair` is deprecated. Use one
+  of the other constructors instead.
+
+### Fixed
+
+- Varints where the last byte was larger than what would fit in 64bit were
+  triggering undefined behaviour. This can only happen when the message
+  being decoded was corrupt in some way.
+- Do not assert when reading too long varints for bools any more. A valid
+  encoder should never generate varints with more than one byte for bools,
+  but if they are longer that's not really a problem, so just handle it.
+- Throw exception if the length of a packed repeated field of a fixed-length
+  type is invalid. The length must always be a multiple of the size of the
+  underlying type. This can only happen if the data is corrupted in some way,
+  a valid encoder would never generate data like this.
+- Throw an exception when reading invalid tags. This can only happen if the
+  data is corrupted in some way, a valid encoder would never generate invalid
+  tags.
+
+
+## [1.5.3] - 2017-09-22
+
+### Added
+
+- More documentation.
+- New `size()` method on iterator range used for packed repeated fields to
+  find out how many elements there are in the range. This is much faster
+  compared to the `std::difference()` call you had to do before, because the
+  varints don't have to be fully decoded. See [Advanced
+  Topics](doc/advanced.md) for details.
+
+### Changed
+
+- Updated clang-tidy settings in Makefiles and fixed a lot of minor issues
+  reported by clang-tidy.
+- Update included catch.hpp to version 1.10.0.
+- Miscellaneous code cleanups.
+- Support for invalid state in `pbf_writer` and `packed_repeated_fields`.
+  This fixes move construction and move assignement in `pbf_writer` and
+  disables the copy construction and copy assignement which don't have
+  clear semantics. It introduces an invalid or empty state in the
+  `pbf_writer`, `pbf_builder`, and `packed_repeated_fields` classes used for
+  default-constructed, moved from, or committed objects. There is a new
+  `commit()` function for `pbf_writer` and the `packed_repeated_fields` which
+  basically does the same as the destructor but can be called explicitly.
+
+### Fixed
+
+- The `empty()` method of the iterator range now returns a `bool` instead of
+  a `size_t`.
+
+
+## [1.5.2] - 2017-06-30
+
+### Added
+
+- Add missing two-parameter version of `pbf_message::next()` function.
+- Add `data_view::empty()` function.
+- Add missing versions of `add_bytes()`, `add_string()`, and `add_message()`
+  to `pbf_builder`.
+
+### Changed
+
+- Clarify include file usage in tutorial.
+- Updated included Catch unit test framework to version 1.9.6 and updated
+  tests to work with the current version.
+- Make some constructors explicit (best practice to avoid silent conversions).
+
+### Fixed
+
+- Important bugfix in `data_view` equality operator. The equality operator is
+  actually never used in the protozero code itself, but users of protozero
+  might use it. This is a serious bug that could lead to buffer overrun type
+  problems.
+
+
+## [1.5.1] - 2017-01-14
+
+### Added
+
+- Better documentation for `tag_and_type()` in doc/advanced.md.
+
+### Fixed
+
+- Fixed broken "make doc" build.
+
+
+## [1.5.0] - 2017-01-12
+
+### Added
+
+- Add `add_bytes_vectored()` methods to `pbf_writer` and `pbf_builder`. This
+  allows single-copy scatter-gather type adding of data that has been prepared
+  in pieces to a protobuf message.
+- New functions to check the tag and wire type at the same time: Two parameter
+  version of `pbf_reader::next()` and `pbf_reader::tag_and_type()` can be used
+  together with the free function `tag_and_type()` to easily and quickly check
+  that not only the tag but also the wire type is correct for a field.
+
+### Changed
+
+- `packed_field_*` classes now work with `pbf_builder`.
+- Reorganized documentation. Advanced docs are now under doc/advanced.md.
+
+### Fixed
+
+- `packed_field` class is now non-copyable because data can get corrupted if
+  you copy it around.
+- Comparison operators of `data_view` now have const& parameters.
+- Make zigzag encoding/decoding functions constexpr.
+
+
+## [1.4.5] - 2016-11-18
+
+### Fixed
+
+- Undefined behaviour in packed fixed iterator. As a result, the macro
+  `PROTOZERO_DO_NOT_USE_BARE_POINTER` is not used any more.
+
+
+## [1.4.4] - 2016-11-15
+
+### Fixed
+
+- Byteswap implementation.
+
+
+## [1.4.3] - 2016-11-15
+
+### Fixed
+
+- Undefined behaviour in byte swapping code.
+- Rename some parameters to avoid "shadow" warning from some compilers.
+
+
+## [1.4.2] - 2016-08-27
+
+### Fixed
+
+- Compile fix: Variable shadowing.
+
+
+## [1.4.1] - 2016-08-21
+
+### Fixed
+
+- GCC 4.8 compile fixed
+
+### Added
+
+- New ability to dynamically require the module as a node module to ease
+  building against from other node C++ modules.
+
+## [1.4.0] - 2016-07-22
+
+### Changed
+
+- Use more efficient new `skip_varint()` function when iterating over
+  packed varints.
+- Split `decode_varint()` function into two functions speeding up the
+  common case where a varint is only one byte long.
+- Introduce new class `iterator_range` used instead of `std::pair` of
+  iterators. This way the objects can be used in range-based for loops.
+  Read UPGRADING.md for details.
+- Introduce new class `data_view` and functions using and returning it.
+  Read UPGRADING.md for details.
+
+
+## [1.3.0] - 2016-02-18
+
+### Added
+
+- Added `config.hpp` header which now includes all the macro magic to
+  configure the library for different architectures etc.
+- New way to create repeated packed fields without using an iterator.
+- Add `rollback()` function to `pbf_writer` for "manual" rollback.
+
+### Changed
+
+- Various test and documentation cleanups.
+- Rename `pbf_types.hpp` to `types.hpp`.
+
+
+## [1.2.3] - 2015-11-30
+
+### Added
+
+- Added `config.hpp` header which now includes all the macro magic to
+  configure the library for different architectures etc.
+
+### Fixed
+
+- Unaligned access to floats/doubles on some ARM architectures.
+
+
+## [1.2.2] - 2015-10-13
+
+### Fixed
+
+- Fix the recently broken writing of bools on big-endian architectures.
+
+
+## [1.2.1] - 2015-10-12
+
+### Fixed
+
+- Removed unneeded code (1-byte "swap") which lead to test failures.
+
+
+## [1.2.0] - 2015-10-08
+
+### Added
+
+- `pbf_message` and `pbf_builder` template classes wrapping `pbf_reader`
+  and `pbf_writer`, respectively. The new classes are the preferred
+  interface now.
+
+### Changed
+
+- Improved byte swapping operation.
+- Detect some types of data corruption earlier and throw.
+
+
+## [1.1.0] - 2015-08-22
+
+### Changed
+
+- Make pbf reader and writer code endianess-aware.
+
+
+[unreleased]: https://github.com/osmcode/libosmium/compare/v1.6.2...HEAD
+[1.6.2]: https://github.com/osmcode/libosmium/compare/v1.6.1...v1.6.2
+[1.6.1]: https://github.com/osmcode/libosmium/compare/v1.6.0...v1.6.1
+[1.6.0]: https://github.com/osmcode/libosmium/compare/v1.5.3...v1.6.0
+[1.5.3]: https://github.com/osmcode/libosmium/compare/v1.5.2...v1.5.3
+[1.5.2]: https://github.com/osmcode/libosmium/compare/v1.5.1...v1.5.2
+[1.5.1]: https://github.com/osmcode/libosmium/compare/v1.5.0...v1.5.1
+[1.5.0]: https://github.com/osmcode/libosmium/compare/v1.4.5...v1.5.0
+[1.4.5]: https://github.com/osmcode/libosmium/compare/v1.4.4...v1.4.5
+[1.4.4]: https://github.com/osmcode/libosmium/compare/v1.4.3...v1.4.4
+[1.4.3]: https://github.com/osmcode/libosmium/compare/v1.4.2...v1.4.3
+[1.4.2]: https://github.com/osmcode/libosmium/compare/v1.4.1...v1.4.2
+[1.4.1]: https://github.com/osmcode/libosmium/compare/v1.4.0...v1.4.1
+[1.4.0]: https://github.com/osmcode/libosmium/compare/v1.3.0...v1.4.0
+[1.3.0]: https://github.com/osmcode/libosmium/compare/v1.2.3...v1.3.0
+[1.2.3]: https://github.com/osmcode/libosmium/compare/v1.2.2...v1.2.3
+[1.2.2]: https://github.com/osmcode/libosmium/compare/v1.2.1...v1.2.2
+[1.2.1]: https://github.com/osmcode/libosmium/compare/v1.2.0...v1.2.1
+[1.2.0]: https://github.com/osmcode/libosmium/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/osmcode/libosmium/compare/v1.0.0...v1.1.0
+
diff --git a/third_party/protozero/CMakeLists.txt b/third_party/protozero/CMakeLists.txt
new file mode 100644
index 00000000000..24e293d739f
--- /dev/null
+++ b/third_party/protozero/CMakeLists.txt
@@ -0,0 +1,145 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake config
+#
+#  protozero
+#
+#-----------------------------------------------------------------------------
+
+cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
+
+#-----------------------------------------------------------------------------
+
+project(protozero)
+
+set(PROTOZERO_VERSION_MAJOR 1)
+set(PROTOZERO_VERSION_MINOR 6)
+set(PROTOZERO_VERSION_PATCH 2)
+
+set(PROTOZERO_VERSION
+    "${PROTOZERO_VERSION_MAJOR}.${PROTOZERO_VERSION_MINOR}.${PROTOZERO_VERSION_PATCH}")
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+#-----------------------------------------------------------------------------
+
+option(WERROR "Add -Werror flag to build (turns warnings into errors)" ON)
+
+if(MSVC)
+    add_definitions(-std=c++11 /W3)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS)
+else()
+    add_definitions(-std=c++11 -Wall -Wextra -pedantic -Wsign-compare -Wunused-parameter -Wno-float-equal -Wno-covered-switch-default)
+    if(WERROR)
+        add_definitions(-Werror)
+    endif()
+endif()
+
+include_directories("${CMAKE_SOURCE_DIR}/include")
+
+set(PROTOZERO_DATA_VIEW "" CACHE STRING "Type used for protozero::data_view")
+if(NOT PROTOZERO_DATA_VIEW STREQUAL "")
+    add_definitions(-DPROTOZERO_DATA_VIEW=${PROTOZERO_DATA_VIEW})
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Find dependencies
+#
+#-----------------------------------------------------------------------------
+
+find_package(Protobuf)
+
+
+#-----------------------------------------------------------------------------
+#
+#  Optional "clang-tidy" target
+#
+#-----------------------------------------------------------------------------
+message(STATUS "Looking for clang-tidy")
+find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-6.0 clang-tidy-5.0)
+
+if(CLANG_TIDY)
+    message(STATUS "Looking for clang-tidy - found ${CLANG_TIDY}")
+    add_custom_target(clang-tidy
+        ${CLANG_TIDY}
+        -p ${CMAKE_BINARY_DIR}
+        ${CMAKE_SOURCE_DIR}/test/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/t/*/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/unit/*.cpp
+        ${CMAKE_SOURCE_DIR}/tools/*.cpp
+    )
+    add_dependencies(clang-tidy writer_tests)
+else()
+    message(STATUS "Looking for clang-tidy - not found")
+    message(STATUS "  Build target 'clang-tidy' will not be available.")
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Optional "cppcheck" target
+#
+#-----------------------------------------------------------------------------
+message(STATUS "Looking for cppcheck")
+find_program(CPPCHECK NAMES cppcheck)
+
+if(CPPCHECK)
+    message(STATUS "Looking for cppcheck - found")
+    add_custom_target(cppcheck
+        ${CPPCHECK}
+        -Uassert --std=c++11 --enable=all
+        ${CMAKE_SOURCE_DIR}/include/protozero/*.hpp
+        ${CMAKE_SOURCE_DIR}/test/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/include/*.hpp
+        ${CMAKE_SOURCE_DIR}/test/t/*/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/unit/*.cpp
+        ${CMAKE_SOURCE_DIR}/tools/*.cpp
+    )
+else()
+    message(STATUS "Looking for cppcheck - not found")
+    message(STATUS "  Build target 'cppcheck' will not be available.")
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Include what you use
+#
+#-----------------------------------------------------------------------------
+message(STATUS "Looking for iwyu")
+find_program(IWYU_TOOL NAMES iwyu_tool)
+
+if(IWYU_TOOL)
+    message(STATUS "Looking for iwyu - found")
+    add_custom_target(iwyu
+        ${IWYU_TOOL} -p ${CMAKE_BINARY_DIR}
+    )
+else()
+    message(STATUS "Looking for iwyu - not found")
+    message(STATUS "  Build target 'iwyu' will not be available.")
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Installation
+#
+#-----------------------------------------------------------------------------
+
+install(DIRECTORY include/protozero DESTINATION include)
+
+
+#-----------------------------------------------------------------------------
+
+enable_testing()
+
+add_subdirectory(doc)
+
+add_subdirectory(tools)
+
+add_subdirectory(test)
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/protozero/CONTRIBUTING.md b/third_party/protozero/CONTRIBUTING.md
new file mode 100644
index 00000000000..c116f600b0f
--- /dev/null
+++ b/third_party/protozero/CONTRIBUTING.md
@@ -0,0 +1,21 @@
+# Contributing to protozero
+
+## Releasing
+
+To release a new protozero version:
+
+ - Make sure all tests are passing locally, on travis and on appveyor
+ - Make sure "make doc" builds
+ - Update version number in
+   - include/protozero/version.hpp (two places)
+   - CMakeLists.txt (one place)
+ - Update CHANGELOG.md
+   (don't forget links at the bottom of the file)
+ - Update UPGRADING.md if necessary
+ - `git commit -m "Release X.Y.Z" include/protozero/version.hpp CMakeLists.txt CHANGELOG.md UPGRADING.md`
+ - `git tag vX.Y.Z`
+ - `git push`
+ - `git push --tags`
+ - Go to https://github.com/mapbox/protozero/releases
+   and edit the new release. Put "Version x.y.z" in title and
+   cut-and-paste entry from CHANGELOG.md.
diff --git a/third_party/protozero/FUZZING.md b/third_party/protozero/FUZZING.md
new file mode 100644
index 00000000000..44ae0ef1694
--- /dev/null
+++ b/third_party/protozero/FUZZING.md
@@ -0,0 +1,22 @@
+
+To do fuzz testing using [AFL](http://lcamtuf.coredump.cx/afl/) compile with
+the AFL compiler wrappers:
+
+    mkdir build
+    cd build
+    CC=afl-clang CXX=afl-clang++ cmake ..
+    mkdir testcase_dir
+
+You need some data to start the fuzzing. In this case I am using all the test
+messages from the unit tests:
+
+    find ../test/t/ -name data-\*.pbf -a -not -empty -exec cp {} testcase_dir/ \;
+
+Then do the actual fuzzing:
+
+    afl-fuzz -i testcase_dir -o findings_dir -- tools/pbf-decoder -
+
+See the AFL documentation for more information.
+
+This only checkes the reading side of Protozero!
+
diff --git a/third_party/protozero/LICENSE.from_folly b/third_party/protozero/LICENSE.from_folly
new file mode 100644
index 00000000000..f433b1a53f5
--- /dev/null
+++ b/third_party/protozero/LICENSE.from_folly
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/third_party/protozero/LICENSE.md b/third_party/protozero/LICENSE.md
new file mode 100644
index 00000000000..d0b30117c13
--- /dev/null
+++ b/third_party/protozero/LICENSE.md
@@ -0,0 +1,24 @@
+protozero copyright (c) Mapbox.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the
+      distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/third_party/protozero/README.md b/third_party/protozero/README.md
new file mode 100644
index 00000000000..63972e0a6ae
--- /dev/null
+++ b/third_party/protozero/README.md
@@ -0,0 +1,156 @@
+# protozero
+
+Minimalistic protocol buffer decoder and encoder in C++.
+
+Designed for high performance. Suitable for writing zero copy parsers and
+encoders with minimal need for run-time allocation of memory.
+
+Low-level: this is designed to be a building block for writing a very
+customized decoder for a stable protobuf schema. If your protobuf schema is
+changing frequently or lazy decoding is not critical for your application then
+this approach offers no value: just use the C++ API that can be generated with
+the Google Protobufs `protoc` program.
+
+[![Travis Build Status](https://travis-ci.org/mapbox/protozero.svg?branch=master)](https://travis-ci.org/mapbox/protozero)
+[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/mapbox/protozero?svg=true)](https://ci.appveyor.com/project/Mapbox/protozero)
+[![Coverage Status](https://codecov.io/gh/mapbox/protozero/branch/master/graph/badge.svg)](https://codecov.io/gh/mapbox/protozero)
+[![Packaging status](https://repology.org/badge/tiny-repos/protozero.svg)](https://repology.org/metapackage/protozero)
+
+## Depends
+
+* C++11 compiler
+* CMake
+* Some tests depend on the Google Protobuf library, but use of Protozero
+  doesn't need it
+
+
+## How it works
+
+The protozero code does **not** read `.proto` files used by the usual Protobuf
+implementations. The developer using protozero has to manually "translate" the
+`.proto` description into code. This means there is no way to access any of the
+information from the `.proto` description. This results in a few restrictions:
+
+* The names of the fields are not available.
+* Enum names are not available, you'll have to use the values they are defined
+  with.
+* Default values are not available.
+* Field types have to be hardcoded. The library does not know which types to
+  expect, so the user of the library has to supply the right types. Some checks
+  are made using `assert()`, but mostly the user has to take care of that.
+
+The library will make sure not to overrun the buffer it was given, but
+basically all other checks have to be made in user code!
+
+
+## Documentation
+
+You have to have a working knowledge of how
+[protocol buffer encoding works](https://developers.google.com/protocol-buffers/docs/encoding).
+
+* Read the [tutorial](doc/tutorial.md) for an introduction on how to use
+  Protozero.
+* Some advanced topics are described in an [extra document](doc/advanced.md).
+* There is a table of all types and functions in the
+  [cheat sheet](doc/cheatsheet.md).
+* Read the [upgrading instructions](UPGRADING.md) if you are upgrading from
+  an older version of Protozero.
+
+The build process will also build the Doxygen-based reference documentation
+if you have [Doxygen](http://www.stack.nl/~dimitri/doxygen/) installed. Then
+open `doc/html/index.html` in your browser to read it.
+
+
+## Endianness
+
+Protozero uses a very simplistic test to check the byte order of the system it
+compiles on. If this check is wrong, you'll get test failures. If this is the
+case, please [open an issue](https://github.com/mapbox/protozero/issues) and
+tell us about your system.
+
+
+## Building tests
+
+Extensive tests are included. Build them using CMake:
+
+    mkdir build
+    cd build
+    cmake ..
+    make
+
+Call `ctest` to run the tests.
+
+The unit and reader tests are always build, the writer tests are only build if
+the Google Protobuf library is found when running CMake.
+
+See `test/README.md` for more details about the test.
+
+
+## Coverage report
+
+To get a coverage report set `CXXFLAGS` and `LDFLAGS` before calling CMake:
+
+    CXXFLAGS="--coverage" LDFLAGS="--coverage" cmake ..
+
+Then call `make` as usual and run the tests using `ctest`.
+
+If you are using `g++` use `gcov` to generate a report (results are in `*.gcov`
+files):
+
+    gcov -lp $(find test/ -name '*.o')
+
+If you are using `clang++` use `llvm-cov` instead:
+
+    llvm-cov gcov -lp $(find test/ -name '*.o')
+
+If you are using `g++` you can use `gcovr` to generate nice HTML output:
+
+    mkdir -p coverage
+    gcovr . -r SRCDIR --html --html-details -o coverage/index.html
+
+Open `coverage/index.html` in your browser to see the report.
+
+
+## Clang-tidy
+
+After the CMake step, run
+
+    make clang-tidy
+
+to check the code with [clang-tidy](https://clang.llvm.org/extra/clang-tidy/).
+You might have to set `CLANG_TIDY` in CMake config.
+
+
+## Cppcheck
+
+For extra checks with [Cppcheck](http://cppcheck.sourceforge.net/) you can,
+after the CMake step, call
+
+    make cppcheck
+
+
+## Installation
+
+After the CMake step, call `make install` to install the include files in
+`/usr/local/include/protozero`.
+
+If you are using CMake to build your own software, you can copy the file
+`cmake/FindProtozero.cmake` and use it in your build. See the file for
+details.
+
+
+## Who is using Protozero?
+
+* [Carmen](https://github.com/mapbox/carmen-cache)
+* [Libosmium](https://github.com/osmcode/libosmium)
+* [Mapbox GL Native](https://github.com/mapbox/mapbox-gl-native)
+* [Mapbox Vector Tile library](https://github.com/mapbox/vector-tile)
+* [Mapnik](https://github.com/mapbox/mapnik-vector-tile)
+* [OSRM](https://github.com/Project-OSRM/osrm-backend)
+* [Tippecanoe](https://github.com/mapbox/tippecanoe)
+* [Vtzero](https://github.com/mapbox/vtzero)
+
+Are you using Protozero? Tell us! Send a pull request with changes to this
+README.
+
+
diff --git a/third_party/protozero/UPGRADING.md b/third_party/protozero/UPGRADING.md
new file mode 100644
index 00000000000..9a5db8ee926
--- /dev/null
+++ b/third_party/protozero/UPGRADING.md
@@ -0,0 +1,96 @@
+
+# Upgrading
+
+This file contains instructions for users of Protozero who are upgrading from
+one version to another.
+
+You do not need to change anything if only the minor version changes, but it
+is better to keep up with changes if you can. The switch to the next major
+version will be easier then. And you might get some more convenient usage.
+
+To help you with upgrading to new versions, you can define the C++ preprocessor
+macro `PROTOZERO_STRICT_API` in which case Protozero will compile without the
+code used for backwards compatibilty. You will then get compile errors for
+older API usages.
+
+## Upgrading from *v1.5* to *v1.6.0*
+
+* The `data_view` class moved from `types.hpp` into its own header file
+  `data_view.hpp`. Most people should not include those headers directly,
+  but if you do, you might have to change your includes.
+* There are two new exceptions `invalid_tag_exception` and
+  `invalid_length_exception` which cover cases that were only checked by
+  `assert` before this version. If you catch specific exceptions in your code
+  you might have to amend it. But just catching `protozero::exception` is
+  usually fine for most code (if you catch exceptions at all).
+* The `pbf_reader` constructor taking a `std::pair` is now deprecated. If you
+  are compiling with `PROTOZERO_STRICT_API` it is not available any more. Use
+  one of the other constructors instead.
+
+## Upgrading from *v1.4.5* to *v1.5.0*
+
+* New functions for checking tag and type at the same time to make your
+  program more robust. Read the section "Repeated fields in messages" in
+  the new [Advanced Topics documentation](doc/advanced.md).
+
+## Upgrading from *v1.4.4* to *v1.4.5*
+
+* The macro `PROTOZERO_DO_NOT_USE_BARE_POINTER` is not used any more. If you
+  have been setting this, remove it.
+
+## Upgrading from *v1.4.0* to *v1.4.1*
+
+* You can now do `require('protozero')` in nodejs to print the path
+  to the include paths for the protozero headers.
+
+## Upgrading from *v1.3.0* to *v1.4.0*
+
+* Functions in `pbf_reader` (and the derived `pbf_message`) called
+  `get_packed_*()` now return an `iterator_range` instead of a `std::pair`.
+  The new class is derived from `std::pair`, so changes are usually not
+  strictly necessary. For future compatibility, you should change all
+  attribute accesses on the returned objects from `first` and `second` to
+  `begin()` and `end()`, respectively. So change something like this:
+
+      auto x = message.get_packed_int32();
+      for (auto it = x.first; it != x.second; ++it) {
+          ....
+      }
+
+  to:
+
+      auto x = message.get_packed_int32();
+      for (auto it = x.begin(); it != x.end(); ++it) {
+          ....
+      }
+
+  or even better use the range-based for loop:
+
+      auto x = message.get_packed_int32();
+      for (auto val : x) {
+          ....
+      }
+
+  Ranges can also be used in this way. This will change the range in-place:
+
+      auto range = message.get_packed_int32();
+      while (!range.empty()) {
+          auto value = range.front();
+          range.drop_front();
+          ....
+      }
+
+* The class `pbf_reader` has a new method `get_view()` returning an object
+  of the new `protozero::data_view` class. The `data_view` only has minimal
+  functionality, but what it has is compatible to the `std::string_view` class
+  which will be coming in C++17. The view autoconverts to a `std::string` if
+  needed. Use `get_view()` instead of `get_data()` giving you a more intuitive
+  interface (call `data()` and `size()` on the view instead of using `first`
+  and `second` on the `std::pair` returned by `get_data()`).
+
+  You can set the macro `PROTOZERO_USE_VIEW` (before including `types.hpp`) to
+  the name of any class that behaves like `protozero::data_view` and
+  `data_view` will be an alias to that class instead of the implementation
+  from protozero. This way you can use the C++17 `string_view` or a similar
+  class if it is already available on your system.
+
diff --git a/third_party/protozero/appveyor.yml b/third_party/protozero/appveyor.yml
new file mode 100644
index 00000000000..3c3dc7bced9
--- /dev/null
+++ b/third_party/protozero/appveyor.yml
@@ -0,0 +1,57 @@
+#-----------------------------------------------------------------------------
+#
+#  Configuration for continuous integration service at appveyor.com
+#
+#-----------------------------------------------------------------------------
+
+platform: x64
+
+image: Visual Studio 2017
+
+clone_depth: 1
+
+#-----------------------------------------------------------------------------
+
+environment:
+  matrix:
+  - config: MSYS2
+    autocrlf: true
+  - config: Debug
+    autocrlf: true
+  - config: RelWithDebInfo
+    autocrlf: true
+  - config: Debug
+    autocrlf: false
+  - config: RelWithDebInfo
+    autocrlf: false
+
+#-----------------------------------------------------------------------------
+
+init:
+  - git config --global core.autocrlf %autocrlf%
+  - git config --get core.autocrlf
+
+# The option --ask=20 is a workaround for a problem with the MSYS2 update
+# process. Without it the following error is printed and the appveyor script
+# halts: "msys2-runtime and catgets are in conflict. Remove catgets?"
+# See also: https://github.com/Alexpux/MSYS2-packages/issues/1141
+install:
+  - if [%config%]==[MSYS2] (
+          C:\msys64\usr\bin\pacman --noconfirm --sync --refresh --refresh --sysupgrade --sysupgrade --ask=20
+       && C:\msys64\usr\bin\pacman -Rc --noconfirm mingw-w64-x86_64-gcc-libs
+    )
+
+build_script:
+  - if [%config%]==[MSYS2] (
+        build-msys2.bat
+    ) else (
+        build-appveyor.bat
+    )
+
+# remove garbage VS messages
+# http://help.appveyor.com/discussions/problems/4569-the-target-_convertpdbfiles-listed-in-a-beforetargets-attribute-at-c-does-not-exist-in-the-project-and-will-be-ignored
+before_build:
+  - del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/protozero/bench/data/README.md b/third_party/protozero/bench/data/README.md
new file mode 100644
index 00000000000..202f94db114
--- /dev/null
+++ b/third_party/protozero/bench/data/README.md
@@ -0,0 +1,13 @@
+
+
+mapbox-streets-v6/14/8714/8017.vector.pbf
+
+ - http://c.tile.openstreetmap.org/14/8714/8017.png
+ - https://a.tiles.mapbox.com/v4/mapbox.mapbox-streets-v6/14/8714/8017.vector.pbf
+ - https://www.mapbox.com/developers/vector-tiles/mapbox-streets/
+
+enf-14-4824-6157.vector.pbf
+
+ - enf.8k273nmi
+ - https://b.tiles.mapbox.com/v4/enf.c3a2de35/14/4824/6157@2x.png
+ - https://www.mapbox.com/blog/twitter-map-every-tweet/
\ No newline at end of file
diff --git a/third_party/protozero/bench/data/enf-14-4824-6157.vector.pbf b/third_party/protozero/bench/data/enf-14-4824-6157.vector.pbf
new file mode 100644
index 00000000000..dcd8717b4f8
Binary files /dev/null and b/third_party/protozero/bench/data/enf-14-4824-6157.vector.pbf differ
diff --git a/third_party/protozero/bench/data/mapbox-streets-v6-14-8714-8017.vector.pbf b/third_party/protozero/bench/data/mapbox-streets-v6-14-8714-8017.vector.pbf
new file mode 100644
index 00000000000..9553b22daea
Binary files /dev/null and b/third_party/protozero/bench/data/mapbox-streets-v6-14-8714-8017.vector.pbf differ
diff --git a/third_party/protozero/build-appveyor.bat b/third_party/protozero/build-appveyor.bat
new file mode 100644
index 00000000000..76e848c29c4
--- /dev/null
+++ b/third_party/protozero/build-appveyor.bat
@@ -0,0 +1,65 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~ %~f0 ~~~~~~
+
+::show all available env vars
+SET
+ECHO cmake on AppVeyor
+cmake -version
+
+ECHO activating VS cmd prompt && CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET protobuf_sdk=protozero-dep-protobuf-2.6.1.7z
+IF EXIST %protobuf_sdk% (ECHO protobuf already downloaded) ELSE (ECHO downloading protobuf ... && powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/$env:protobuf_sdk -OutFile $pwd\$env:protobuf_sdk)
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+IF EXIST deps\protobuf (ECHO protobuf already extracted) ELSE (CALL 7z x -y %protobuf_sdk% | %windir%\system32\FIND "ing archive")
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+SET PATH=%~dp0deps\protobuf;%PATH%
+
+IF EXIST build ECHO deleting build dir... && RD /Q /S build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+MKDIR build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+CD build
+ECHO config^: %config%
+
+::This will produce lots of LNK4099 warnings which can be ignored.
+::Unfortunately they can't be disabled, see
+::http://stackoverflow.com/questions/661606/visual-c-how-to-disable-specific-linker-warnings
+SET CMAKE_CMD=cmake .. ^
+-LA -G "Visual Studio 14 Win64"
+
+ECHO calling^: %CMAKE_CMD%
+%CMAKE_CMD%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET avlogger=
+IF /I "%APPVEYOR%"=="True" SET avlogger=/logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+
+msbuild protozero.sln ^
+/p:Configuration=%config% ^
+/toolsversion:14.0 ^
+/p:Platform=x64 ^
+/p:PlatformToolset=v140 %avlogger%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ctest --output-on-failure ^
+-C %config% ^
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+:ERROR
+ECHO ~~~~~~ ERROR %~f0 ~~~~~~
+SET EL=%ERRORLEVEL%
+
+:DONE
+IF %EL% NEQ 0 ECHO. && ECHO !!! ERRORLEVEL^: %EL% !!! && ECHO.
+ECHO ~~~~~~ DONE %~f0 ~~~~~~
+
+EXIT /b %EL%
diff --git a/third_party/protozero/build-local.bat b/third_party/protozero/build-local.bat
new file mode 100644
index 00000000000..62db254ac0c
--- /dev/null
+++ b/third_party/protozero/build-local.bat
@@ -0,0 +1,29 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO =========== %~f0 ===========
+
+SET VERBOSITY_MSBUILD=diagnostic
+IF NOT "%1"=="" SET VERBOSITY_MSBUILD=%1
+SET platform=x64
+SET configuration=Release
+CALL build-appveyor.bat %VERBOSITY_MSBUILD%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET platform=x86
+SET configuration=Debug
+CALL build-appveyor.bat %VERBOSITY_MSBUILD%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+:ERROR
+ECHO =========== ERROR %~f0 ===========
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO =========== DONE %~f0 ===========
+
+EXIT /b %EL%
diff --git a/third_party/protozero/build-msys2.bat b/third_party/protozero/build-msys2.bat
new file mode 100644
index 00000000000..1a02156b596
--- /dev/null
+++ b/third_party/protozero/build-msys2.bat
@@ -0,0 +1,18 @@
+echo "Adding MSYS2 to path..."
+SET "PATH=C:\msys64\mingw64\bin;C:\msys64\usr\bin;%PATH%"
+echo %PATH%
+
+echo "Installing MSYS2 packages..."
+bash -lc "pacman -S --needed --noconfirm mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake mingw-w64-x86_64-doxygen mingw-w64-x86_64-protobuf"
+
+echo "Generating makefiles"
+mkdir build
+cd build
+cmake .. -LA -G "MSYS Makefiles"
+
+echo "Building"
+make VERBOSE=1
+
+echo "Testing"
+ctest --output-on-failure
+
diff --git a/third_party/protozero/cmake/FindProtozero.cmake b/third_party/protozero/cmake/FindProtozero.cmake
new file mode 100644
index 00000000000..ad16cabeb00
--- /dev/null
+++ b/third_party/protozero/cmake/FindProtozero.cmake
@@ -0,0 +1,63 @@
+#----------------------------------------------------------------------
+#
+#  FindProtozero.cmake
+#
+#  Find the protozero headers.
+#
+#----------------------------------------------------------------------
+#
+#  Usage:
+#
+#    Copy this file somewhere into your project directory, where cmake can
+#    find it. Usually this will be a directory called "cmake" which you can
+#    add to the CMake module search path with the following line in your
+#    CMakeLists.txt:
+#
+#      list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+#
+#    Then add the following in your CMakeLists.txt:
+#
+#      find_package(Protozero [version] [REQUIRED])
+#      include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
+#
+#    The version number is optional. If it is not set, any version of
+#    protozero will do.
+#
+#      if(NOT PROTOZERO_FOUND)
+#          message(WARNING "Protozero not found!\n")
+#      endif()
+#
+#----------------------------------------------------------------------
+#
+#  Variables:
+#
+#    PROTOZERO_FOUND        - True if Protozero was found.
+#    PROTOZERO_INCLUDE_DIR  - Where to find include files.
+#
+#----------------------------------------------------------------------
+
+# find include path
+find_path(PROTOZERO_INCLUDE_DIR protozero/version.hpp
+    PATH_SUFFIXES include
+    PATHS ${CMAKE_SOURCE_DIR}/../protozero
+)
+
+# Check version number
+if(Protozero_FIND_VERSION)
+    file(STRINGS "${PROTOZERO_INCLUDE_DIR}/protozero/version.hpp" _version_define REGEX "#define PROTOZERO_VERSION_STRING")
+    if("${_version_define}" MATCHES "#define PROTOZERO_VERSION_STRING \"([0-9.]+)\"")
+        set(_version "${CMAKE_MATCH_1}")
+    else()
+        set(_version "unknown")
+    endif()
+endif()
+
+#set(PROTOZERO_INCLUDE_DIRS "${PROTOZERO_INCLUDE_DIR}")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Protozero
+                                  REQUIRED_VARS PROTOZERO_INCLUDE_DIR
+                                  VERSION_VAR _version)
+
+
+#----------------------------------------------------------------------
diff --git a/third_party/protozero/doc/CMakeLists.txt b/third_party/protozero/doc/CMakeLists.txt
new file mode 100644
index 00000000000..77c5420a665
--- /dev/null
+++ b/third_party/protozero/doc/CMakeLists.txt
@@ -0,0 +1,37 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake Config
+#
+#  protozero documentation
+#
+#-----------------------------------------------------------------------------
+
+message(STATUS "Configuring documentation")
+
+message(STATUS "Looking for doxygen")
+find_package(Doxygen)
+
+if(DOXYGEN_FOUND)
+    message(STATUS "Looking for doxygen - found")
+    configure_file(Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+
+    file(GLOB HEADER_FILES "${CMAKE_SOURCE_DIR}/include/protozero/*.hpp")
+    add_custom_command(OUTPUT html/index.html
+        COMMAND ${DOXYGEN_EXECUTABLE}
+        ARGS ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+        DEPENDS Doxyfile.in advanced.md cheatsheet.md tutorial.md
+                ${HEADER_FILES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Generating API documentation with Doxygen" VERBATIM)
+    add_custom_target(doc ALL
+                      DEPENDS html/index.html)
+else()
+    message(STATUS "Looking for doxygen - not found")
+    message(STATUS "  Disabled making of documentation.")
+endif()
+
+#-----------------------------------------------------------------------------
+message(STATUS "Configuring documentation - done")
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/protozero/doc/Doxyfile.in b/third_party/protozero/doc/Doxyfile.in
new file mode 100644
index 00000000000..1481905511a
--- /dev/null
+++ b/third_party/protozero/doc/Doxyfile.in
@@ -0,0 +1,2355 @@
+# Doxyfile 1.8.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all text
+# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
+# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
+# for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = "protozero"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         = @PROTOZERO_VERSION@
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "Minimalistic protocol buffer decoder and encoder in C++."
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
+# the documentation. The maximum height of the logo should not exceed 55 pixels
+# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
+# to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = "@PROJECT_BINARY_DIR@/doc"
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       =
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        = @PROJECT_SOURCE_DIR@
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
+# new page for each member. If set to NO, the documentation of a member will be
+# part of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines.
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
+# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
+# Fortran. In the later case the parser tries to guess whether the code is fixed
+# or free formatted code, this is the default for Fortran type files), VHDL. For
+# instance to make doxygen treat .inc files as Fortran files (default is PHP),
+# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+#
+# Note For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by by putting a % sign in front of the word
+# or globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO these classes will be included in the various overviews. This option has
+# no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) declarations. If set to NO these declarations will be
+# included in the documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
+# todo list. This list is created by putting \todo commands in the
+# documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
+# test list. This list is created by putting \test commands in the
+# documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES the list
+# will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = YES
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO doxygen will only warn about wrong or incomplete parameter
+# documentation, but not about the absence of documentation.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces.
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = @PROJECT_SOURCE_DIR@/README.md \
+                         @PROJECT_SOURCE_DIR@/UPGRADING.md \
+                         @PROJECT_SOURCE_DIR@/doc \
+                         @PROJECT_SOURCE_DIR@/include/protozero
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: http://www.gnu.org/software/libiconv) for the list of
+# possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank the
+# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
+# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
+# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
+# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
+# *.qsf, *.as and *.js.
+
+FILE_PATTERNS          =
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        = protozero::detail protozero_assert PROTOZERO_*_ENDIAN PROTOZERO_BYTE_ORDER
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       =
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER ) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE = @PROJECT_SOURCE_DIR@/README.md
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# function all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see http://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the
+# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+# cost of reduced performance. This can be particularly helpful with template
+# rich C++ code for which doxygen's built-in parser lacks the necessary type
+# information.
+# Note: The availability of this option depends on whether or not doxygen was
+# compiled with the --with-libclang option.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefor more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra stylesheet files is of importance (e.g. the last
+# stylesheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the stylesheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: http://developer.apple.com/tools/xcode/), introduced with
+# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler ( hhc.exe). If non-empty
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated (
+# YES) or that it should be included in the master .chm file ( NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated (
+# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using prerendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. To get the times font for
+# instance you can specify
+# EXTRA_PACKAGES=times
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
+# for the replacement values of the other commands the user is refered to
+# HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's config
+# file, i.e. a series of assignments. You only have to provide replacements,
+# missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's config file. A template extensions file can be generated
+# using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
+# Definitions (see http://autogen.sf.net) file that captures the structure of
+# the code including all documentation. Note that this feature is still
+# experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
+# in the source code. If set to NO only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES the includes files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
+# class index. If set to NO only the inherited external classes will be listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
+# the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES, the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: YES.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot.
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
+# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
+# gif:cairo:gd, gif:gd, gif:gd:gd and svg.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+PLANTUML_JAR_PATH      =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/third_party/protozero/doc/advanced.md b/third_party/protozero/doc/advanced.md
new file mode 100644
index 00000000000..f5a0e112085
--- /dev/null
+++ b/third_party/protozero/doc/advanced.md
@@ -0,0 +1,271 @@
+
+# Protozero Advanced Topics
+
+This documentation contains some mixed advanced topics for Protozero users.
+Read the [tutorial](tutorial.md) first if you are new to Protozero.
+
+
+## Limitations of Protozero
+
+* A protobuf message has to fit into memory completely, otherwise it can not
+  be parsed with this library. There is no streaming support.
+* The length of a string, bytes, or submessage can't be more than 2^31-1.
+* There is no specific support for maps but they can be used as described in
+  the "Backwards compatibility" section of
+  https://developers.google.com/protocol-buffers/docs/proto3#maps.
+
+
+## Checking the Protozero version number
+
+If `protozero/version.hpp` is included, the following macros are set:
+
+| Macro                      | Example | Description                                    |
+| -------------------------- | ------- | ---------------------------------------------- |
+| `PROTOZERO_VERSION_MAJOR`  | 1       | Major version number                           |
+| `PROTOZERO_VERSION_MINOR`  | 3       | Minor version number                           |
+| `PROTOZERO_VERSION_PATCH`  | 2       | Patch number                                   |
+| `PROTOZERO_VERSION_CODE`   | 10302   | Version (major * 10,000 + minor * 100 + patch) |
+| `PROTOZERO_VERSION_STRING` | "1.3.2" | Version string                                 |
+
+
+## Changing Protozero behaviour with macros
+
+The behaviour of Protozero can be changed by defining the following macros.
+They have to be set before including any of the Protozero headers.
+
+### `PROTOZERO_STRICT_API`
+
+If this is set, you will get some extra warnings or errors during compilation
+if you are using an old (deprecated) interface to Protozero. Enable this if
+you want to make sure your code will work with future versions of Protozero.
+
+### `PROTOZERO_USE_VIEW`
+
+Protozero uses the class `protozero::data_view` as the return type of the
+`pbf_reader::get_view()` method and a few other functions take a
+`protozero::data_view` as parameter.
+
+If `PROTOZERO_USE_VIEW` is unset, `protozero::data_view` is Protozero's own
+implementation of a *string view* class.
+
+Set this macro if you want to use a different implementation such as the C++17
+`std::string_view` class. In this case `protozero::data_view` will simply be
+an alias to the class you specify.
+
+    #define PROTOZERO_USE_VIEW std::string_view
+
+
+## Repeated fields in messages
+
+The Google Protobuf spec documents that a non-repeated field can actually
+appear several times in a message and the implementation is required to return
+the value of the last version of that field in this case. `pbf_reader.hpp` does
+not enforce this. If this feature is needed in your case, you have to do this
+yourself.
+
+The [spec also
+says](https://developers.google.com/protocol-buffers/docs/encoding#packed)
+that you must be able to read a packed repeated field where a not-packed
+repeated field is expected and vice versa. Also there can be several (packed or
+not-packed) repeated fields with the same tag and their contents must be
+concatenated. It is your responsibility to do this, Protozero doesn't do that
+for you.
+
+### Using `tag_and_type()`
+
+The `tag_and_type()` free function and the method of the same name on the
+`pbf_reader` and `pbf_message` classes can be used to access both packed and
+unpacked repeated fields. (It can also be used to check that you have the
+right type of encoding for other fields.)
+
+Here is the outline:
+
+```cpp
+enum class ExampleMsg : protozero::pbf_tag_type {
+    repeated_uint32_x = 1
+};
+
+std::string data = ...
+pbf_message<ExampleMsg> message{data};
+while (message.next()) {
+    switch (message.tag_and_type()) {
+        case tag_and_type(ExampleMsg::repeated_uint32_x, pbf_wire_type::length_delimited): {
+                auto xit = message.get_packed_uint32();
+                ... // handle the repeated field when it is packed
+            }
+            break;
+        case tag_and_type(ExampleMsg::repeated_uint32_x, pbf_wire_type::varint): {
+                auto x = message.get_uint32();
+                ... // handle the repeated field when it is not packed
+            }
+            break;
+        default:
+            message.skip();
+    }
+}
+```
+
+All this works on `pbf_reader` in the same way as with `pbf_message` with the
+usual difference that `pbf_reader` takes a numeric field tag and `pbf_message`
+an enum field.
+
+If you only want to check for one specific tag and type you can use the
+two-argument version of `pbf_reader::next()`. In this case `17` is the field
+tag we are looking for:
+
+```cpp
+std::string data = ...
+pbf_reader message{data};
+while (message.next(17, pbf_wire_type::varint)) {
+    auto foo = message.get_int32();
+    ...
+}
+```
+
+See the test under `test/t/tag_and_type/` for a complete example.
+
+
+## Reserving memory when writing messages
+
+If you know beforehand how large a message will become or can take an educated
+guess, you can call the usual `std::string::reserve()` on the underlying string
+before you give it to an `pbf_writer` or `pbf_builder` object.
+
+Or you can (at any time) call `reserve()` on the `pbf_writer` or `pbf_builder`.
+This will reserve the given amount of bytes *in addition to whatever is already
+in that message*. (Note that this behaviour is different then what `reserve()`
+does on `std::string` or `std::vector`.)
+
+In the general case it is not easy to figure out how much memory you will need
+because of the varint packing of integers. But sometimes you can make at least
+a rough estimate. Still, you should probably only use this facility if you have
+benchmarks proving that it actually makes your program faster.
+
+
+## Using the low-level varint and zigzag encoding and decoding functions
+
+Protozero gives you access to the low-level functions for encoding and
+decoding varint and zigzag integer encodings, because these functions can
+sometimes be useful outside the Protocol Buffer context.
+
+### Using low-level functions
+
+To use the low-level functions, add this include to your C++ program:
+
+```cpp
+#include <protozero/varint.hpp>
+```
+
+### Functions
+
+The following functions are then available:
+
+```cpp
+decode_varint()
+write_varint()
+encode_zigzag32()
+encode_zigzag64()
+decode_zigzag32()
+decode_zigzag64()
+```
+
+See the reference documentation created by `make doc` for details.
+
+
+## Vectored input for length-delimited fields
+
+Length-delimited fields (like string fields, byte fields and messages) are
+usually set by calling `add_string()`, `add_message()`, etc. These functions
+have several forms, but they basically all take a *tag*, a *size*, and a
+*pointer to the data*. They write the length of the data into the message
+and then copy the data over.
+
+Sometimes you have the data not in one place, but spread over several
+buffers. In this case you have to consolidate those buffers first, which needs
+an extra copy. Say you have two very long strings that should be concatenated
+into a message:
+
+```cpp
+std::string a{"very long string..."};
+std::string b{"another very long string..."};
+
+std::string data;
+protozero::pbf_writer writer{data};
+
+a.append(b); // expensive extra copy
+
+writer.add_string(1, a);
+```
+
+To avoid this, the function `add_bytes_vectored()` can be used which allows
+vectored (or scatter/gather) input like this:
+
+```cpp
+std::string a{"very long string..."};
+std::string b{"another very long string..."};
+
+std::string data;
+protozero::pbf_writer writer{data};
+
+writer.add_bytes_vectored(1, a, b);
+```
+
+`add_bytes_vectored()` will add up the sizes of all its arguments and copy over
+all the data only once.
+
+The function takes any number of arguments. The arguments must be of a type
+supporting the `data()` and `size()` methods like `protozero::data_view()`,
+`std::string` or the C++17 `std::string_view`.
+
+Note that there is only one version of the function which can be used for any
+length-delimited field including strings, bytes, messages and repeated packed
+fields.
+
+The function is also available in the `pbf_builder` class.
+
+
+## Internal handling of varints
+
+When varints are decoded they are always decoded as 64bit unsigned integers and
+after that casted to the type you are requesting (using `static_cast`). This
+means that if the protocol buffer message was created with a different integer
+type than what you are reading it with, you might get wrong results without any
+warning or error. This is the same behaviour as the Google Protocol Buffers
+library has.
+
+In normal use, this should never matter, because presumably you are using the
+same types to write that data as you are using to read it later. It can happen
+if the data is corrupted intentionally or unintentionally in some way. But
+this can't be used to feed you any data that it wasn't possible to feed you
+without this behaviour, so it doesn't open up any potential problems. You
+always have to check anyway that the integers are in the range you expected
+them to be in if the expected range is different than the range of the integer
+type. This is especially true for enums which protozero will return as
+`int32_t`.
+
+
+## How many items are there in a repeated packed field?
+
+Sometimes it is useful to know how many values there are in a repeated packed
+field. For instance when you want to reserve space in a `std::vector`.
+
+```cpp
+protozero::pbf_reader message{...};
+message.next(...);
+const auto range = message.get_packed_sint32();
+
+std::vector<int> myvalues;
+myvalues.reserve(range.size());
+
+for (auto value : range) {
+    myvalues.push_back(value);
+}
+```
+
+It depends on the type of range how expensive the `size()` call is. For ranges
+derived from packed repeated fixed sized values the effort will be constant,
+for ranges derived from packed repeated varints, the effort will be linear, but
+still considerably cheaper than decoding the varints. You have to benchmark
+your use case to see whether the `reserve()` (or whatever you are using the
+`size()` for) is worth it.
+
diff --git a/third_party/protozero/doc/cheatsheet.md b/third_party/protozero/doc/cheatsheet.md
new file mode 100644
index 00000000000..128ec67404b
--- /dev/null
+++ b/third_party/protozero/doc/cheatsheet.md
@@ -0,0 +1,67 @@
+
+# Protozero Cheat Sheet
+
+See also this
+[handy table](https://developers.google.com/protocol-buffers/docs/proto#scalar)
+from the Google Protocol Buffers documentation.
+
+## Scalar types
+
+| PBF Type | Underlying Storage | C++ Type      | Getter           | Notes |
+| -------- | ------------------ | ------------- | ---------------- | ----- |
+| int32    | varint             | `int32_t`     | `get_int32()`    |       |
+| sint32   | varint (zigzag)    | `int32_t`     | `get_sint32()`   |       |
+| uint32   | varint             | `uint32_t`    | `get_uint32()`   |       |
+| int64    | varint             | `int64_t`     | `get_int64()`    |       |
+| sint64   | varint (zigzag)    | `int64_t`     | `get_sint64()`   |       |
+| uint64   | varint             | `uint64_t`    | `get_uint64()`   |       |
+| bool     | varint             | `bool`        | `get_bool()`     |       |
+| enum     | varint             | `int32_t`     | `get_enum()`     |       |
+| fixed32  | 32bit fixed        | `uint32_t`    | `get_fixed32()`  |       |
+| sfixed32 | 32bit fixed        | `int32_t`     | `get_sfixed32()` |       |
+| fixed64  | 64bit fixed        | `uint64_t`    | `get_fixed64()`  |       |
+| sfixed64 | 64bit fixed        | `int64_t`     | `get_sfixed64()` |       |
+| float    | 32bit fixed        | `float`       | `get_float()`    |       |
+| double   | 64bit fixed        | `double`      | `get_double()`   |       |
+| string   | length-delimited   | `data_view`   | `get_view()`     | (1)   |
+| string   | length-delimited   | pair          | `get_data()`     | (2)   |
+| string   | length-delimited   | `std::string` | `get_string()`   |       |
+| bytes    | length-delimited   | `data_view`   | `get_view()`     | (1)   |
+| bytes    | length-delimited   | pair          | `get_data()`     | (2)   |
+| bytes    | length-delimited   | `std::string` | `get_bytes()`    |       |
+| message  | length-delimited   | `data_view`   | `get_view()`     | (1)   |
+| message  | length-delimited   | pair          | `get_data()`     | (2)   |
+| message  | length-delimited   | `pbf_reader`  | `get_message()`  |       |
+
+### Notes:
+
+* (1) preferred form, returns `protozero::data_view` which is convertible to
+  `std::string` if needed.
+* (2) deprecated form, returns `std::pair<const char*, pbf_length_type>`,
+  use `get_view()` instead. This form is only available if
+  `PROTOZERO_STRICT_API` is not defined.
+* The setter function of `pbf_writer` is always `add_` + the PBF type. Several
+  overloads are available.
+
+
+## Packed repeated fields
+
+| PBF Type | Getter                  |
+| -------- | ----------------------- |
+| int32    | `get_packed_int32()`    |
+| sint32   | `get_packed_sint32()`   |
+| uint32   | `get_packed_uint32()`   |
+| int64    | `get_packed_int64()`    |
+| sint64   | `get_packed_sint64()`   |
+| uint64   | `get_packed_uint64()`   |
+| bool     | `get_packed_bool()`     |
+| enum     | `get_packed_enum()`     |
+| fixed32  | `get_packed_fixed32()`  |
+| sfixed32 | `get_packed_sfixed32()` |
+| fixed64  | `get_packed_fixed64()`  |
+| sfixed64 | `get_packed_sfixed64()` |
+| float    | `get_packed_float()`    |
+| double   | `get_packed_double()`   |
+
+Packed repeated fields for string, bytes, and message types are not possible.
+
diff --git a/third_party/protozero/doc/tutorial.md b/third_party/protozero/doc/tutorial.md
new file mode 100644
index 00000000000..cccb69af4f9
--- /dev/null
+++ b/third_party/protozero/doc/tutorial.md
@@ -0,0 +1,626 @@
+
+# Protozero Tutorial
+
+## Getting to know Protocol Buffers
+
+Protozero is a very low level library. You really have to know some of the
+insides of Protocol Buffers to work with it!
+
+So before reading any further in this document, read the following from the
+Protocol Buffer documentation:
+
+* [Developer Guide - Overview](https://developers.google.com/protocol-buffers/docs/overview)
+* [Language Guide](https://developers.google.com/protocol-buffers/docs/proto)
+* [Encoding](https://developers.google.com/protocol-buffers/docs/encoding)
+
+Make sure you understand the basic types of values supported by Protocol
+Buffers. Refer to this
+[handy table](https://developers.google.com/protocol-buffers/docs/proto#scalar)
+and [the cheat sheet](cheatsheet.md) if you are getting lost.
+
+
+## Prerequisites
+
+You need a C++11-capable compiler for Protozero to work. Copy the files in the
+`include/protozero` directory somewhere where your build system can find them.
+Keep the `protozero` directory and include the files in the form
+
+```cpp
+#include <protozero/FILENAME.hpp>
+```
+
+
+## Parsing protobuf-encoded messages
+
+### Using `pbf_reader`
+
+To use the `pbf_reader` class, add this include to your C++ program:
+
+```cpp
+#include <protozero/pbf_reader.hpp>
+```
+
+The `pbf_reader` class contains asserts that will detect some programming
+errors. We encourage you to compile with asserts enabled in your debug builds.
+
+
+### An introductory example
+
+Lets say you have a protocol description in a `.proto` file like this:
+
+```cpp
+message Example1 {
+    required uint32 x  =  1;
+    optional string s  =  2;
+    repeated fixed64 r = 17;
+}
+```
+
+To read messages created according to that description, you will have code that
+looks somewhat like this:
+
+```cpp
+#include <protozero/pbf_reader.hpp>
+
+// get data from somewhere into the input string
+std::string input = get_input_data();
+
+// initialize pbf message with this data
+protozero::pbf_reader message{input};
+
+// iterate over fields in the message
+while (message.next()) {
+
+    // switch depending on the field tag (the field name is not available)
+    switch (message.tag()) {
+        case 1:
+            // get data for tag 1 (in this case an uint32)
+            auto x = message.get_uint32();
+            break;
+        case 2:
+            // get data for tag 2 (in this case a string)
+            std::string s = message.get_string();
+            break;
+        case 17:
+            // ignore data for tag 17
+            message.skip();
+            break;
+        default:
+            // ignore data for unknown tags to allow for future extensions
+            message.skip();
+    }
+}
+```
+
+You always have to call `next()` and then either one of the accessor functions
+(like `get_uint32()` or `get_string()`) to get the field value or `skip()` to
+ignore this field. Then call `next()` again, and so forth. Never call `next()`
+twice in a row or any if the accessor or skip functions twice in a row.
+
+Because the `pbf_reader` class doesn't know the `.proto` file it doesn't know
+which field names or tags there are and it doesn't known the types of the
+fields. You have to make sure to call the right `get_...()` function for each
+tag. Some `assert()s` are done to check you are calling the right functions,
+but not all errors can be detected.
+
+Note that it doesn't matter whether a field is defined as `required`,
+`optional`, or `repeated`. You always have to be prepared to get zero, one, or
+more instances of a field and you always have to be prepared to get other
+fields, too, unless you want your program to break if somebody adds a new
+field.
+
+
+### If you only need a single field
+
+If, out of a protocol buffer message, you only need the value of a single
+field, you can use the version of the `next()` function with a parameter:
+
+```cpp
+// same .proto file and initialization as above
+
+// get all fields with tag 17, skip all others
+while (message.next(17)) {
+    auto r = message.get_fixed64();
+    std::cout << r << "\n";
+}
+```
+
+### Handling scalar fields
+
+As you saw in the example, handling scalar field types is reasonably easy. You
+just check the `.proto` file for the type of a field and call the corresponding
+function called `get_` + _field type_.
+
+For `string` and `bytes` types the internal handling is exactly the same, but
+both `get_string()` and `get_bytes()` are provided to make the code
+self-documenting. Both theses calls allocate and return a `std::string` which
+can add some overhead. You can call the `get_view()` function instead which
+returns a `data_view` containing a pointer into the data (access with `data()`)
+and the length of the data (access with `size()`).
+
+
+### Handling repeated packed fields
+
+Fields that are marked as `[packed=true]` in the `.proto` file are handled
+somewhat differently. `get_packed_...()` functions returning an iterator range
+are used to access the data.
+
+So, for example, if you have a protocol description in a `.proto` file like
+this:
+
+```cpp
+message Example2 {
+    repeated sint32 i = 1 [packed=true];
+}
+```
+
+You can get to the data like this:
+
+```cpp
+protozero::pbf_reader message{input.data(), input.size()};
+
+// set current field
+message.next(1);
+
+// get an iterator range
+auto pi = message.get_packed_sint32();
+
+// iterate to get to all values
+for (auto it = pi.begin(); it != pi.end(); ++it) {
+    std::cout << *it << '\n';
+}
+```
+
+Or, with a range-based for-loop:
+
+```cpp
+for (auto value : pi) {
+    std::cout << v << '\n';
+}
+```
+
+So you are getting a pair of normal forward iterators wrapped in an iterator
+range object. The iterators can be used with any STL algorithms etc.
+
+Note that the previous only applies to repeated **packed** fields, normal
+repeated fields are handled in the usual way for scalar fields.
+
+
+### Handling embedded messages
+
+Protocol Buffers can embed any message inside another message. To access an
+embedded message use the `get_message()` function. So for this description:
+
+```cpp
+message Point {
+    required double x = 1;
+    required double y = 2;
+}
+
+message Example3 {
+    repeated Point point = 10;
+}
+```
+
+you can parse with this code:
+
+```cpp
+protozero::pbf_reader message{input};
+
+while (message.next(10)) {
+    protozero::pbf_reader point = message.get_message();
+    double x, y;
+    while (point.next()) {
+        switch (point.tag()) {
+            case 1:
+                x = point.get_double();
+                break;
+            case 2:
+                y = point.get_double();
+                break;
+            default:
+                point.skip();
+        }
+    }
+    std::cout << "x=" << x << " y=" << y << "\n";
+}
+```
+
+### Handling enums
+
+Enums are stored as varints and they can't be differentiated from them. Use
+the `get_enum()` function to get the value of the enum, you have to translate
+this into the symbolic name yourself. See the `enum` test case for an example.
+
+
+### Asserts and exceptions in the Protozero library
+
+Protozero uses `assert()` liberally to help you find bugs in your own code when
+compiled in debug mode (ie with `NDEBUG` not set). If such an assert "fires",
+this is a very strong indication that there is a bug in your code somewhere.
+
+(Protozero will disable those asserts and "convert" them into exception in its
+own test code. This is done to make sure the asserts actually work as intended.
+Your test code will not need this!)
+
+Exceptions, on the other hand, are thrown by Protozero if some kind of data
+corruption was detected while it is trying to parse the data. This could also
+be an indicator for a bug in the user code, but because it can happen if the
+data was (intentionally or not intentionally) been messed with, it is reported
+to the user code using exceptions.
+
+Most of the functions on the writer side can throw a `std::bad_alloc`
+exception if there is no space to grow a buffer. Other than that no exceptions
+can occur on the writer side.
+
+All exceptions thrown by the reader side derive from `protozero::exception`.
+
+Note that all exceptions can also happen if you are expecting a data field of
+a certain type in your code but the field actually has a different type. In
+that case the `pbf_reader` class might interpret the bytes in the buffer in
+the wrong way and anything can happen.
+
+#### `end_of_buffer_exception`
+
+This will be thrown whenever any of the functions "runs out of input data".
+It means you either have an incomplete message in your input or some other
+data corruption has taken place.
+
+#### `unknown_pbf_wire_type_exception`
+
+This will be thrown if an unsupported wire type is encountered. Either your
+input data is corrupted or it was written with an unsupported version of a
+Protocol Buffers implementation.
+
+#### `varint_too_long_exception`
+
+This exception indicates an illegal encoding of a varint. It means your input
+data is corrupted in some way.
+
+#### `invalid_tag_exception`
+
+This exception is thrown when a tag has an invalid value. Tags must be
+unsigned integers between 1 and 2^29-1. Tags between 19000 and 19999 are not
+allowed. See
+https://developers.google.com/protocol-buffers/docs/proto#assigning-tags
+
+#### `invalid_length_exception`
+
+This exception is thrown when a length field of a packed repeated field is
+invalid. For fixed size types the length must be a multiple of the size of
+the type.
+
+### The `pbf_reader` class
+
+The `pbf_reader` class behaves like a value type. Objects are reasonably small
+(two pointers and two `uint32_t`, so 24 bytes on a 64bit system) and they can
+be copied and moved around trivially.
+
+`pbf_reader` objects can be constructed from a `std::string` or a `const char*`
+and a length field (either supplied as separate arguments or as a `std::pair`).
+In all cases objects of the `pbf_reader` class store a pointer into the input
+data that was given to the constructor. You have to make sure this pointer
+stays valid for the duration of the objects lifetime.
+
+## Parsing protobuf-encoded messages using `pbf_message`
+
+One problem in the code above are the "magic numbers" used as tags for the
+different fields that you got from the `.proto` file. Instead of spreading
+these magic numbers around your code you can define them once in an `enum
+class` and then use the `pbf_message` template class instead of the
+`pbf_reader` class.
+
+Here is the first example again, this time using this new technique. So you
+have the following in a `.proto` file:
+
+```cpp
+message Example1 {
+    required uint32 x  =  1;
+    optional string s  =  2;
+    repeated fixed64 r = 17;
+}
+```
+
+Add the following declaration in one of your header files:
+
+```cpp
+enum class Example1 : protozero::pbf_tag_type {
+    required_uint32_x  =  1,
+    optional_string_s  =  2,
+    repeated_fixed64_r = 17
+};
+```
+
+The message name becomes the name of the `enum class` which is always built
+on top of the `protozero::pbf_tag_type` type. Each field in the message
+becomes one value of the enum. In this case the name is created from the
+type (including the modifiers like `required` or `optional`) and the name of
+the field. You can use any name you want, but this convention makes it easier
+later, to get everything right.
+
+To read messages created according to that description, you will have code that
+looks somewhat like this, this time using `pbf_message` instead of
+`pbf_reader`:
+
+```cpp
+#include <protozero/pbf_message.hpp>
+
+// get data from somewhere into the input string
+std::string input = get_input_data();
+
+// initialize pbf message with this data
+protozero::pbf_message<Example1> message{input};
+
+// iterate over fields in the message
+while (message.next()) {
+
+    // switch depending on the field tag (the field name is not available)
+    switch (message.tag()) {
+        case Example1::required_uint32_x:
+            auto x = message.get_uint32();
+            break;
+        case Example1::optional_string_s:
+            std::string s = message.get_string();
+            break;
+        case Example1::repeated_fixed64_r:
+            message.skip();
+            break;
+        default:
+            // ignore data for unknown tags to allow for future extensions
+            message.skip();
+    }
+}
+```
+
+Note the correspondance between the enum value (for instance
+`required_uint32_x`) and the name of the getter function (for instance
+`get_uint32()`). This makes it easier to get the correct types. Also the
+naming makes it easier to keep different message types apart if you have
+multiple (or embedded) messages.
+
+See the `test/t/complex` test case for a complete example using this interface.
+
+Using `pbf_message` in favour of `pbf_reader` is recommended for all code.
+Note that `pbf_message` derives from `pbf_reader`, so you can always fall
+back to the more generic interface if necessary.
+
+One problem you might run into is the following: The enum class lists all
+possible values you know about and you'll have lots of `switch` statements
+checking those values. Some compilers will know that your `switch` covers
+all possible cases and warn you if you have a `default` case that looks
+unneccessary to the compiler. But you still want that `default` case to allow
+for future extension of those messages (and maybe also to detect corrupted
+data). You can switch of this warning with `-Wno-covered-switch-default`).
+
+
+## Writing protobuf-encoded messages
+
+### Using `pbf_writer`
+
+To use the `pbf_writer` class, add this include to your C++ program:
+
+```cpp
+#include <protozero/pbf_writer.hpp>
+```
+
+The `pbf_writer` class contains asserts that will detect some programming
+errors. We encourage you to compile with asserts enabled in your debug builds.
+
+
+### An introductory example
+
+Lets say you have a protocol description in a `.proto` file like this:
+
+```cpp
+message Example {
+    required uint32 x = 1;
+    optional string s = 2;
+    repeated fixed64 r = 17;
+}
+```
+
+To write messages created according to that description, you will have code
+that looks somewhat like this:
+
+```cpp
+#include <protozero/pbf_writer.hpp>
+
+std::string data;
+protozero::pbf_writer pbf_example{data};
+
+pbf_example.add_uint32(1, 27);       // uint32_t x
+pbf_example.add_fixed64(17, 1);      // fixed64 r
+pbf_example.add_fixed64(17, 2);
+pbf_example.add_fixed64(17, 3);
+pbf_example.add_string(2, "foobar"); // string s
+```
+
+First you need a string which will be used as buffer to assemble the
+protobuf-formatted message. The `pbf_writer` object contains a reference to
+this string buffer and through it you add data to that buffer piece by piece.
+The buffer doesn't have to be empty, the `pbf_writer` will simply append its
+data to whatever is there already.
+
+
+### Handling scalar fields
+
+As you could see in the introductory example handling any kind of scalar field
+is easy. The type of field doesn't matter and it doesn't matter whether it is
+optional, required or repeated. You always call one of the `add_TYPE()` method
+on the pbf writer object.
+
+The first parameter of these methods is always the *tag* of the field (the
+field number) from the `.proto` file. The second parameter is the value you
+want to set. For the `bytes` and `string` types several versions of the add
+method are available taking a `const std::string&` or a `const char*` and a
+length.
+
+For `enum` types you have to use the numeric value as the symbolic names from
+the `.proto` file are not available.
+
+
+### Handling repeated packed fields
+
+Repeated packed fields can easily be set from a pair of iterators:
+
+```cpp
+std::string data;
+protozero::pbf_writer pw{data};
+
+std::vector<int> v = { 1, 4, 9, 16, 25, 36 };
+pw.add_packed_int32(1, std::begin(v), std::end(v));
+```
+
+If you don't have an iterator you can use the alternative form:
+
+```cpp
+std::string data;
+protozero::pbf_writer pw{data};
+{
+    protozero::packed_field_int32 field{pw, 1};
+    field.add_element(1);
+    field.add_element(10);
+    field.add_element(100);
+}
+```
+
+Of course you can add as many elements as you want. If you add no elements
+at all, this code will still work, Protozero detects this special case and
+pretends you never even initialized this field.
+
+The nested scope is important in this case, because the destructor of the
+`field` object will make sure the length stored inside the field is set to
+the right value. You must close that scope before adding other fields to the
+`pw` pbf writer.
+
+If you know how many elements you will add to the field and your field contains
+fixed length elements, you can tell Protozero and it can optimize this case:
+
+```cpp
+std::string data;
+protozero::pbf_writer pw{data};
+{
+    protozero::packed_field_fixed32 field{pw, 1, 2}; // exactly two elements
+    field.add_element(42);
+    field.add_element(13);
+}
+```
+
+In this case you have to supply exactly as many elements as you promised,
+otherwise you will get a broken protobuf message.
+
+This works for `packed_field_fixed32`, `packed_field_sfixed32`,
+`packed_field_fixed64`, `packed_field_sfixed64`, `packed_field_float`, and
+`packed_field_double`.
+
+You can abandon writing of the packed field if this becomes necessary by
+calling `rollback()`:
+
+```cpp
+std::string data;
+protozero::pbf_writer pw{data};
+{
+    protozero::packed_field_int32 field{pw, 1};
+    field.add_element(42);
+    // some error occurs, you don't want to have this field at all
+    field.rollback();
+}
+```
+
+The result is the same as if the lines inside the nested brackets had never
+been called. Do not try to call `add_element()` after a rollback.
+
+
+### Handling sub-messages
+
+Nested sub-messages can be handled by first creating the submessage and then
+adding to the parent message:
+
+```cpp
+std::string buffer_sub;
+protozero::pbf_writer pbf_sub{buffer_sub};
+
+// add fields to sub-message
+pbf_sub.add_...(...);
+// ...
+
+// sub-message is finished here
+
+std::string buffer_parent;
+protozero::pbf_writer pbf_parent{buffer_parent};
+pbf_parent.add_message(1, buffer_sub);
+```
+
+This is easy to do but it has the drawback of needing a separate `std::string`
+buffer. If this concerns you (and why would you use protozero and not the
+Google protobuf library if it doesn't?) there is another way:
+
+```cpp
+std::string data;
+protozero::pbf_writer pbf_parent{data};
+
+// optionally add fields to parent here
+pbf_parent.add_...(...);
+
+// open a new scope
+{
+    // create new pbf_writer with parent and the tag (field number)
+    // as parameters
+    protozero::pbf_writer pbf_sub{pbf_parent, 1};
+
+    // add fields to sub here...
+    pbf_sub.add_...(...);
+
+} // closing the scope will close the sub-message
+
+// optionally add more fields to parent here
+pbf_parent.add_...(...);
+```
+
+This can be nested arbitrarily deep.
+
+Internally the sub-message writer re-uses the buffer from the parent. It
+reserves enough space in the buffer to later write the length of the submessage
+into it. It then adds the contents of the submessage to the buffer. When the
+`pbf_sub` writer is destructed the length of the submessage is calculated and
+written in the reserved space. If less space was needed for the length field
+than was available, the rest of the buffer is moved over a few bytes.
+
+You can abandon writing of submessage if this becomes necessary by
+calling `rollback()`:
+
+```cpp
+std::string data;
+protozero::pbf_writer pbf_parent{data};
+
+// open a new scope
+{
+    // create new pbf_writer with parent and the tag (field number)
+    // as parameters
+    protozero::pbf_writer pbf_sub{pbf_parent, 1};
+
+    // add fields to sub here...
+    pbf_sub.add_...(...);
+
+    // some problem occurs and you want to abandon the submessage:
+    pbf_sub.rollback();
+}
+
+// optionally add more fields to parent here
+pbf_parent.add_...(...);
+```
+
+The result is the same as if the lines inside the nested brackets had never
+been called. Do not try to call any of the `add_*` functions on the submessage
+after a rollback.
+
+## Writing protobuf-encoded messages using `pbf_builder`
+
+Just like the `pbf_message` template class wraps the `pbf_reader` class, there
+is a `pbf_builder` template class wrapping the `pbf_writer` class. It is
+instantiated using the same `enum class` described above and used exactly
+like the `pbf_writer` class but using the values of the enum instead of bare
+integers.
+
+See the `test/t/complex` test case for a complete example using this interface.
+
diff --git a/third_party/libosmium/include/protozero/byteswap.hpp b/third_party/protozero/include/protozero/byteswap.hpp
similarity index 99%
rename from third_party/libosmium/include/protozero/byteswap.hpp
rename to third_party/protozero/include/protozero/byteswap.hpp
index bca4844cfd3..fd8a83a68b5 100644
--- a/third_party/libosmium/include/protozero/byteswap.hpp
+++ b/third_party/protozero/include/protozero/byteswap.hpp
@@ -16,11 +16,10 @@ documentation.
  * @brief Contains functions to swap bytes in values (for different endianness).
  */
 
-#include <cassert>
-#include <cstdint>
-
 #include <protozero/config.hpp>
 
+#include <cstdint>
+
 namespace protozero {
 namespace detail {
 
diff --git a/third_party/libosmium/include/protozero/config.hpp b/third_party/protozero/include/protozero/config.hpp
similarity index 100%
rename from third_party/libosmium/include/protozero/config.hpp
rename to third_party/protozero/include/protozero/config.hpp
diff --git a/third_party/libosmium/include/protozero/types.hpp b/third_party/protozero/include/protozero/data_view.hpp
similarity index 52%
rename from third_party/libosmium/include/protozero/types.hpp
rename to third_party/protozero/include/protozero/data_view.hpp
index 3dbdaf17b06..952c9120343 100644
--- a/third_party/libosmium/include/protozero/types.hpp
+++ b/third_party/protozero/include/protozero/data_view.hpp
@@ -1,5 +1,5 @@
-#ifndef PROTOZERO_TYPES_HPP
-#define PROTOZERO_TYPES_HPP
+#ifndef PROTOZERO_DATA_VIEW_HPP
+#define PROTOZERO_DATA_VIEW_HPP
 
 /*****************************************************************************
 
@@ -11,57 +11,21 @@ documentation.
 *****************************************************************************/
 
 /**
- * @file types.hpp
+ * @file data_view.hpp
  *
- * @brief Contains the declaration of low-level types used in the pbf format.
+ * @brief Contains the implementation of the data_view class.
  */
 
+#include <protozero/config.hpp>
+
 #include <algorithm>
 #include <cstddef>
-#include <cstdint>
 #include <cstring>
 #include <string>
 #include <utility>
 
-#include <protozero/config.hpp>
-
 namespace protozero {
 
-/**
- * The type used for field tags (field numbers).
- */
-using pbf_tag_type = uint32_t;
-
-/**
- * The type used to encode type information.
- * See the table on
- *    https://developers.google.com/protocol-buffers/docs/encoding
- */
-enum class pbf_wire_type : uint32_t {
-    varint           = 0, // int32/64, uint32/64, sint32/64, bool, enum
-    fixed64          = 1, // fixed64, sfixed64, double
-    length_delimited = 2, // string, bytes, embedded messages,
-                            // packed repeated fields
-    fixed32          = 5, // fixed32, sfixed32, float
-    unknown          = 99 // used for default setting in this library
-};
-
-/**
- * Get the tag and wire type of the current field in one integer suitable
- * for comparison with a switch statement.
- *
- * See pbf_reader.tag_and_type() for an example how to use this.
- */
-template <typename T>
-constexpr inline uint32_t tag_and_type(T tag, pbf_wire_type wire_type) noexcept {
-    return (static_cast<uint32_t>(static_cast<pbf_tag_type>(tag)) << 3) | static_cast<uint32_t>(wire_type);
-}
-
-/**
- * The type used for length values, such as the length of a field.
- */
-using pbf_length_type = uint32_t;
-
 #ifdef PROTOZERO_USE_VIEW
 using data_view = PROTOZERO_USE_VIEW;
 #else
@@ -74,18 +38,15 @@ using data_view = PROTOZERO_USE_VIEW;
  */
 class data_view {
 
-    const char* m_data;
-    std::size_t m_size;
+    const char* m_data = nullptr;
+    std::size_t m_size = 0;
 
 public:
 
     /**
      * Default constructor. Construct an empty data_view.
      */
-    constexpr data_view() noexcept
-        : m_data(nullptr),
-          m_size(0) {
-    }
+    constexpr data_view() noexcept = default;
 
     /**
      * Create data_view from pointer and size.
@@ -103,7 +64,7 @@ class data_view {
      *
      * @param str String with the data.
      */
-    data_view(const std::string& str) noexcept
+    data_view(const std::string& str) noexcept // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
         : m_data(str.data()),
           m_size(str.size()) {
     }
@@ -113,7 +74,7 @@ class data_view {
      *
      * @param ptr Pointer to the data.
      */
-    data_view(const char* ptr) noexcept
+    data_view(const char* ptr) noexcept // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
         : m_data(ptr),
           m_size(std::strlen(ptr)) {
     }
@@ -144,15 +105,21 @@ class data_view {
         return m_size == 0;
     }
 
+#ifndef PROTOZERO_STRICT_API
     /**
      * Convert data view to string.
      *
      * @pre Must not be default constructed data_view.
+     *
+     * @deprecated to_string() is not available in C++17 string_view so it
+     *             should not be used to make conversion to that class easier
+     *             in the future.
      */
     std::string to_string() const {
         protozero_assert(m_data);
-        return std::string{m_data, m_size};
+        return {m_data, m_size};
     }
+#endif
 
     /**
      * Convert data view to string.
@@ -161,7 +128,30 @@ class data_view {
      */
     explicit operator std::string() const {
         protozero_assert(m_data);
-        return std::string{m_data, m_size};
+        return {m_data, m_size};
+    }
+
+    /**
+     * Compares the contents of this object with the given other object.
+     *
+     * @returns 0 if they are the same, <0 if this object is smaller than
+     *          the other or >0 if it is larger. If both objects have the
+     *          same size returns <0 if this object is lexicographically
+     *          before the other, >0 otherwise.
+     *
+     * @pre Must not be default constructed data_view.
+     */
+    int compare(data_view other) const {
+        protozero_assert(m_data && other.m_data);
+        const int cmp = std::memcmp(data(), other.data(),
+                                    std::min(size(), other.size()));
+        if (cmp == 0) {
+            if (size() == other.size()) {
+                return 0;
+            }
+            return size() < other.size() ? -1 : 1;
+        }
+        return cmp;
     }
 
 }; // class data_view
@@ -183,8 +173,9 @@ inline void swap(data_view& lhs, data_view& rhs) noexcept {
  * @param lhs First object.
  * @param rhs Second object.
  */
-inline bool operator==(const data_view& lhs, const data_view& rhs) noexcept {
-    return lhs.size() == rhs.size() && std::equal(lhs.data(), lhs.data() + lhs.size(), rhs.data());
+inline constexpr bool operator==(const data_view lhs, const data_view rhs) noexcept {
+    return lhs.size() == rhs.size() &&
+           std::equal(lhs.data(), lhs.data() + lhs.size(), rhs.data());
 }
 
 /**
@@ -194,13 +185,52 @@ inline bool operator==(const data_view& lhs, const data_view& rhs) noexcept {
  * @param lhs First object.
  * @param rhs Second object.
  */
-inline bool operator!=(const data_view& lhs, const data_view& rhs) noexcept {
+inline constexpr bool operator!=(const data_view lhs, const data_view rhs) noexcept {
     return !(lhs == rhs);
 }
 
-#endif
+/**
+ * Returns true if lhs.compare(rhs) < 0.
+ *
+ * @param lhs First object.
+ * @param rhs Second object.
+ */
+inline bool operator<(const data_view lhs, const data_view rhs) noexcept {
+    return lhs.compare(rhs) < 0;
+}
+
+/**
+ * Returns true if lhs.compare(rhs) <= 0.
+ *
+ * @param lhs First object.
+ * @param rhs Second object.
+ */
+inline bool operator<=(const data_view lhs, const data_view rhs) noexcept {
+    return lhs.compare(rhs) <= 0;
+}
+
+/**
+ * Returns true if lhs.compare(rhs) > 0.
+ *
+ * @param lhs First object.
+ * @param rhs Second object.
+ */
+inline bool operator>(const data_view lhs, const data_view rhs) noexcept {
+    return lhs.compare(rhs) > 0;
+}
+
+/**
+ * Returns true if lhs.compare(rhs) >= 0.
+ *
+ * @param lhs First object.
+ * @param rhs Second object.
+ */
+inline bool operator>=(const data_view lhs, const data_view rhs) noexcept {
+    return lhs.compare(rhs) >= 0;
+}
 
+#endif
 
 } // end namespace protozero
 
-#endif // PROTOZERO_TYPES_HPP
+#endif // PROTOZERO_DATA_VIEW_HPP
diff --git a/third_party/libosmium/include/protozero/exception.hpp b/third_party/protozero/include/protozero/exception.hpp
similarity index 59%
rename from third_party/libosmium/include/protozero/exception.hpp
rename to third_party/protozero/include/protozero/exception.hpp
index ca4340e90d6..a3cd0f15db7 100644
--- a/third_party/libosmium/include/protozero/exception.hpp
+++ b/third_party/protozero/include/protozero/exception.hpp
@@ -29,7 +29,9 @@ namespace protozero {
  */
 struct exception : std::exception {
     /// Returns the explanatory string.
-    const char* what() const noexcept override { return "pbf exception"; }
+    const char* what() const noexcept override {
+        return "pbf exception";
+    }
 };
 
 /**
@@ -38,7 +40,9 @@ struct exception : std::exception {
  */
 struct varint_too_long_exception : exception {
     /// Returns the explanatory string.
-    const char* what() const noexcept override { return "varint too long exception"; }
+    const char* what() const noexcept override {
+        return "varint too long exception";
+    }
 };
 
 /**
@@ -47,7 +51,9 @@ struct varint_too_long_exception : exception {
  */
 struct unknown_pbf_wire_type_exception : exception {
     /// Returns the explanatory string.
-    const char* what() const noexcept override { return "unknown pbf field type exception"; }
+    const char* what() const noexcept override {
+        return "unknown pbf field type exception";
+    }
 };
 
 /**
@@ -60,7 +66,34 @@ struct unknown_pbf_wire_type_exception : exception {
  */
 struct end_of_buffer_exception : exception {
     /// Returns the explanatory string.
-    const char* what() const noexcept override { return "end of buffer exception"; }
+    const char* what() const noexcept override {
+        return "end of buffer exception";
+    }
+};
+
+/**
+ * This exception is thrown when a tag has an invalid value. Tags must be
+ * unsigned integers between 1 and 2^29-1. Tags between 19000 and 19999 are
+ * not allowed. See
+ * https://developers.google.com/protocol-buffers/docs/proto#assigning-tags
+ */
+struct invalid_tag_exception : exception {
+    /// Returns the explanatory string.
+    const char* what() const noexcept override {
+        return "invalid tag exception";
+    }
+};
+
+/**
+ * This exception is thrown when a length field of a packed repeated field is
+ * invalid. For fixed size types the length must be a multiple of the size of
+ * the type.
+ */
+struct invalid_length_exception : exception {
+    /// Returns the explanatory string.
+    const char* what() const noexcept override {
+        return "invalid length exception";
+    }
 };
 
 } // end namespace protozero
diff --git a/third_party/libosmium/include/protozero/iterators.hpp b/third_party/protozero/include/protozero/iterators.hpp
similarity index 51%
rename from third_party/libosmium/include/protozero/iterators.hpp
rename to third_party/protozero/include/protozero/iterators.hpp
index a19f202428d..c1d7d8d69c8 100644
--- a/third_party/libosmium/include/protozero/iterators.hpp
+++ b/third_party/protozero/include/protozero/iterators.hpp
@@ -16,10 +16,6 @@ documentation.
  * @brief Contains the iterators for access to packed repeated fields.
  */
 
-#include <cstring>
-#include <iterator>
-#include <utility>
-
 #include <protozero/config.hpp>
 #include <protozero/varint.hpp>
 
@@ -27,6 +23,11 @@ documentation.
 # include <protozero/byteswap.hpp>
 #endif
 
+#include <algorithm>
+#include <cstring>
+#include <iterator>
+#include <utility>
+
 namespace protozero {
 
 /**
@@ -61,8 +62,8 @@ class iterator_range :
     /**
      * Create iterator range from two iterators.
      *
-     * @param first_iterator Iterator to beginning or range.
-     * @param last_iterator Iterator to end or range.
+     * @param first_iterator Iterator to beginning of range.
+     * @param last_iterator Iterator to end of range.
      */
     constexpr iterator_range(iterator&& first_iterator, iterator&& last_iterator) :
         P(std::forward<iterator>(first_iterator),
@@ -89,11 +90,24 @@ class iterator_range :
         return this->second;
     }
 
-    /// Return true if this range is empty.
-    constexpr std::size_t empty() const noexcept {
+    /**
+     * Return true if this range is empty.
+     *
+     * Complexity: Constant.
+     */
+    constexpr bool empty() const noexcept {
         return begin() == end();
     }
 
+    /**
+     * Get the size of the range, ie the number of elements it contains.
+     *
+     * Complexity: Constant or linear depending on the underlaying iterator.
+     */
+    std::size_t size() const noexcept {
+        return static_cast<size_t>(std::distance(begin(), end()));
+    }
+
     /**
      * Get element at the beginning of the range.
      *
@@ -146,27 +160,20 @@ template <typename T>
 class const_fixed_iterator {
 
     /// Pointer to current iterator position
-    const char* m_data;
-
-    /// Pointer to end iterator position
-    const char* m_end;
+    const char* m_data = nullptr;
 
 public:
 
-    using iterator_category = std::forward_iterator_tag;
+    using iterator_category = std::random_access_iterator_tag;
     using value_type        = T;
     using difference_type   = std::ptrdiff_t;
     using pointer           = value_type*;
     using reference         = value_type&;
 
-    const_fixed_iterator() noexcept :
-        m_data(nullptr),
-        m_end(nullptr) {
-    }
+    const_fixed_iterator() noexcept = default;
 
-    const_fixed_iterator(const char* data, const char* end) noexcept :
-        m_data(data),
-        m_end(end) {
+    explicit const_fixed_iterator(const char* data) noexcept :
+        m_data(data) {
     }
 
     const_fixed_iterator(const const_fixed_iterator&) noexcept = default;
@@ -186,25 +193,89 @@ class const_fixed_iterator {
         return result;
     }
 
-    const_fixed_iterator& operator++() {
+    const_fixed_iterator& operator++() noexcept {
         m_data += sizeof(value_type);
         return *this;
     }
 
-    const_fixed_iterator operator++(int) {
-        const const_fixed_iterator tmp(*this);
+    const_fixed_iterator operator++(int) noexcept {
+        const const_fixed_iterator tmp{*this};
         ++(*this);
         return tmp;
     }
 
-    bool operator==(const const_fixed_iterator& rhs) const noexcept {
-        return m_data == rhs.m_data && m_end == rhs.m_end;
+    bool operator==(const_fixed_iterator rhs) const noexcept {
+        return m_data == rhs.m_data;
     }
 
-    bool operator!=(const const_fixed_iterator& rhs) const noexcept {
+    bool operator!=(const_fixed_iterator rhs) const noexcept {
         return !(*this == rhs);
     }
 
+    const_fixed_iterator& operator--() noexcept {
+        m_data -= sizeof(value_type);
+        return *this;
+    }
+
+    const_fixed_iterator operator--(int) noexcept {
+        const const_fixed_iterator tmp{*this};
+        --(*this);
+        return tmp;
+    }
+
+    friend bool operator<(const_fixed_iterator lhs, const_fixed_iterator rhs) noexcept {
+        return lhs.m_data < rhs.m_data;
+    }
+
+    friend bool operator>(const_fixed_iterator lhs, const_fixed_iterator rhs) noexcept {
+        return rhs < lhs;
+    }
+
+    friend bool operator<=(const_fixed_iterator lhs, const_fixed_iterator rhs) noexcept {
+        return !(lhs > rhs);
+    }
+
+    friend bool operator>=(const_fixed_iterator lhs, const_fixed_iterator rhs) noexcept {
+        return !(lhs < rhs);
+
+    }
+
+    const_fixed_iterator& operator+=(difference_type val) noexcept {
+        m_data += (sizeof(value_type) * val);
+        return *this;
+    }
+
+    friend const_fixed_iterator operator+(const_fixed_iterator lhs, difference_type rhs) noexcept {
+        const_fixed_iterator tmp{lhs};
+        tmp.m_data += (sizeof(value_type) * rhs);
+        return tmp;
+    }
+
+    friend const_fixed_iterator operator+(difference_type lhs, const_fixed_iterator rhs) noexcept {
+        const_fixed_iterator tmp{rhs};
+        tmp.m_data += (sizeof(value_type) * lhs);
+        return tmp;
+    }
+
+    const_fixed_iterator& operator-=(difference_type val) noexcept {
+        m_data -= (sizeof(value_type) * val);
+        return *this;
+    }
+
+    friend const_fixed_iterator operator-(const_fixed_iterator lhs, difference_type rhs) noexcept {
+        const_fixed_iterator tmp{lhs};
+        tmp.m_data -= (sizeof(value_type) * rhs);
+        return tmp;
+    }
+
+    friend difference_type operator-(const_fixed_iterator lhs, const_fixed_iterator rhs) noexcept {
+        return static_cast<difference_type>(lhs.m_data - rhs.m_data) / static_cast<difference_type>(sizeof(T));
+    }
+
+    value_type operator[](difference_type n) const noexcept {
+        return *(*this + n);
+    }
+
 }; // class const_fixed_iterator
 
 /**
@@ -217,10 +288,10 @@ class const_varint_iterator {
 protected:
 
     /// Pointer to current iterator position
-    const char* m_data;
+    const char* m_data = nullptr;
 
     /// Pointer to end iterator position
-    const char* m_end;
+    const char* m_end = nullptr;
 
 public:
 
@@ -230,11 +301,17 @@ class const_varint_iterator {
     using pointer           = value_type*;
     using reference         = value_type&;
 
-    const_varint_iterator() noexcept :
-        m_data(nullptr),
-        m_end(nullptr) {
+    static difference_type distance(const_varint_iterator begin, const_varint_iterator end) noexcept {
+        // We know that each varint contains exactly one byte with the most
+        // significant bit not set. We can use this to quickly figure out
+        // how many varints there are without actually decoding the varints.
+        return std::count_if(begin.m_data, end.m_data, [](char c) noexcept {
+            return (static_cast<unsigned char>(c) & 0x80u) == 0;
+        });
     }
 
+    const_varint_iterator() noexcept = default;
+
     const_varint_iterator(const char* data, const char* end) noexcept :
         m_data(data),
         m_end(end) {
@@ -259,7 +336,7 @@ class const_varint_iterator {
     }
 
     const_varint_iterator operator++(int) {
-        const const_varint_iterator tmp(*this);
+        const const_varint_iterator tmp{*this};
         ++(*this);
         return tmp;
     }
@@ -298,10 +375,10 @@ class const_svarint_iterator : public const_varint_iterator<T> {
     }
 
     const_svarint_iterator(const const_svarint_iterator&) = default;
-    const_svarint_iterator(const_svarint_iterator&&) = default;
+    const_svarint_iterator(const_svarint_iterator&&) noexcept = default;
 
     const_svarint_iterator& operator=(const const_svarint_iterator&) = default;
-    const_svarint_iterator& operator=(const_svarint_iterator&&) = default;
+    const_svarint_iterator& operator=(const_svarint_iterator&&) noexcept = default;
 
     ~const_svarint_iterator() = default;
 
@@ -316,7 +393,7 @@ class const_svarint_iterator : public const_varint_iterator<T> {
     }
 
     const_svarint_iterator operator++(int) {
-        const const_svarint_iterator tmp(*this);
+        const const_svarint_iterator tmp{*this};
         ++(*this);
         return tmp;
     }
@@ -325,4 +402,54 @@ class const_svarint_iterator : public const_varint_iterator<T> {
 
 } // end namespace protozero
 
+namespace std {
+
+    // Specialize std::distance for all the protozero iterators. Because
+    // functions can't be partially specialized, we have to do this for
+    // every value_type we are using.
+
+    template <>
+    inline typename protozero::const_varint_iterator<int32_t>::difference_type
+    distance<protozero::const_varint_iterator<int32_t>>(protozero::const_varint_iterator<int32_t> first, // NOLINT(readability-inconsistent-declaration-parameter-name)
+                                                        protozero::const_varint_iterator<int32_t> last) {
+        return protozero::const_varint_iterator<int32_t>::distance(first, last);
+    }
+
+    template <>
+    inline typename protozero::const_varint_iterator<int64_t>::difference_type
+    distance<protozero::const_varint_iterator<int64_t>>(protozero::const_varint_iterator<int64_t> first, // NOLINT(readability-inconsistent-declaration-parameter-name)
+                                                        protozero::const_varint_iterator<int64_t> last) {
+        return protozero::const_varint_iterator<int64_t>::distance(first, last);
+    }
+
+    template <>
+    inline typename protozero::const_varint_iterator<uint32_t>::difference_type
+    distance<protozero::const_varint_iterator<uint32_t>>(protozero::const_varint_iterator<uint32_t> first, // NOLINT(readability-inconsistent-declaration-parameter-name)
+                                                         protozero::const_varint_iterator<uint32_t> last) {
+        return protozero::const_varint_iterator<uint32_t>::distance(first, last);
+    }
+
+    template <>
+    inline typename protozero::const_varint_iterator<uint64_t>::difference_type
+    distance<protozero::const_varint_iterator<uint64_t>>(protozero::const_varint_iterator<uint64_t> first, // NOLINT(readability-inconsistent-declaration-parameter-name)
+                                                         protozero::const_varint_iterator<uint64_t> last) {
+        return protozero::const_varint_iterator<uint64_t>::distance(first, last);
+    }
+
+    template <>
+    inline typename protozero::const_svarint_iterator<int32_t>::difference_type
+    distance<protozero::const_svarint_iterator<int32_t>>(protozero::const_svarint_iterator<int32_t> first, // NOLINT(readability-inconsistent-declaration-parameter-name)
+                                                         protozero::const_svarint_iterator<int32_t> last) {
+        return protozero::const_svarint_iterator<int32_t>::distance(first, last);
+    }
+
+    template <>
+    inline typename protozero::const_svarint_iterator<int64_t>::difference_type
+    distance<protozero::const_svarint_iterator<int64_t>>(protozero::const_svarint_iterator<int64_t> first, // NOLINT(readability-inconsistent-declaration-parameter-name)
+                                                         protozero::const_svarint_iterator<int64_t> last) {
+        return protozero::const_svarint_iterator<int64_t>::distance(first, last);
+    }
+
+} // end namespace std
+
 #endif // PROTOZERO_ITERATORS_HPP
diff --git a/third_party/libosmium/include/protozero/pbf_builder.hpp b/third_party/protozero/include/protozero/pbf_builder.hpp
similarity index 61%
rename from third_party/libosmium/include/protozero/pbf_builder.hpp
rename to third_party/protozero/include/protozero/pbf_builder.hpp
index 819739585ee..2e74b2fd9a2 100644
--- a/third_party/libosmium/include/protozero/pbf_builder.hpp
+++ b/third_party/protozero/include/protozero/pbf_builder.hpp
@@ -16,11 +16,11 @@ documentation.
  * @brief Contains the pbf_builder template class.
  */
 
-#include <type_traits>
-
 #include <protozero/pbf_writer.hpp>
 #include <protozero/types.hpp>
 
+#include <type_traits>
+
 namespace protozero {
 
 /**
@@ -44,12 +44,27 @@ class pbf_builder : public pbf_writer {
 
 public:
 
+    /// The type of messages this class will build.
     using enum_type = T;
 
+    pbf_builder() = default;
+
+    /**
+     * Create a builder using the given string as a data store. The object
+     * stores a reference to that string and adds all data to it. The string
+     * doesn't have to be empty. The pbf_message object will just append data.
+     */
     explicit pbf_builder(std::string& data) noexcept :
         pbf_writer(data) {
     }
 
+    /**
+     * Construct a pbf_builder for a submessage from the pbf_message or
+     * pbf_writer of the parent message.
+     *
+     * @param parent_writer The parent pbf_message or pbf_writer
+     * @param tag Tag of the field that will be written
+     */
     template <typename P>
     pbf_builder(pbf_writer& parent_writer, P tag) noexcept :
         pbf_writer(parent_writer, pbf_tag_type(tag)) {
@@ -79,51 +94,141 @@ class pbf_builder : public pbf_writer {
 #undef PROTOZERO_WRITER_WRAP_ADD_SCALAR
 /// @endcond
 
+    /**
+     * Add "bytes" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Pointer to value to be written
+     * @param size Number of bytes to be written
+     */
     void add_bytes(T tag, const char* value, std::size_t size) {
         pbf_writer::add_bytes(pbf_tag_type(tag), value, size);
     }
 
+    /**
+     * Add "bytes" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Value to be written
+     */
     void add_bytes(T tag, const data_view& value) {
         pbf_writer::add_bytes(pbf_tag_type(tag), value);
     }
 
+    /**
+     * Add "bytes" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Value to be written
+     */
     void add_bytes(T tag, const std::string& value) {
         pbf_writer::add_bytes(pbf_tag_type(tag), value);
     }
 
+    /**
+     * Add "bytes" field to data. Bytes from the value are written until
+     * a null byte is encountered. The null byte is not added.
+     *
+     * @param tag Tag of the field
+     * @param value Pointer to zero-delimited value to be written
+     */
     void add_bytes(T tag, const char* value) {
         pbf_writer::add_bytes(pbf_tag_type(tag), value);
     }
 
+    /**
+     * Add "bytes" field to data using vectored input. All the data in the
+     * 2nd and further arguments is "concatenated" with only a single copy
+     * into the final buffer.
+     *
+     * This will work with objects of any type supporting the data() and
+     * size() methods like std::string or protozero::data_view.
+     *
+     * Example:
+     * @code
+     * std::string data1 = "abc";
+     * std::string data2 = "xyz";
+     * builder.add_bytes_vectored(1, data1, data2);
+     * @endcode
+     *
+     * @tparam Ts List of types supporting data() and size() methods.
+     * @param tag Tag of the field
+     * @param values List of objects of types Ts with data to be appended.
+     */
     template <typename... Ts>
     void add_bytes_vectored(T tag, Ts&&... values) {
         pbf_writer::add_bytes_vectored(pbf_tag_type(tag), std::forward<Ts>(values)...);
     }
 
+    /**
+     * Add "string" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Pointer to value to be written
+     * @param size Number of bytes to be written
+     */
     void add_string(T tag, const char* value, std::size_t size) {
         pbf_writer::add_string(pbf_tag_type(tag), value, size);
     }
 
+    /**
+     * Add "string" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Value to be written
+     */
     void add_string(T tag, const data_view& value) {
         pbf_writer::add_string(pbf_tag_type(tag), value);
     }
 
+    /**
+     * Add "string" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Value to be written
+     */
     void add_string(T tag, const std::string& value) {
         pbf_writer::add_string(pbf_tag_type(tag), value);
     }
 
+    /**
+     * Add "string" field to data. Bytes from the value are written until
+     * a null byte is encountered. The null byte is not added.
+     *
+     * @param tag Tag of the field
+     * @param value Pointer to value to be written
+     */
     void add_string(T tag, const char* value) {
         pbf_writer::add_string(pbf_tag_type(tag), value);
     }
 
+    /**
+     * Add "message" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Pointer to message to be written
+     * @param size Length of the message
+     */
     void add_message(T tag, const char* value, std::size_t size) {
         pbf_writer::add_message(pbf_tag_type(tag), value, size);
     }
 
+    /**
+     * Add "message" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Value to be written. The value must be a complete message.
+     */
     void add_message(T tag, const data_view& value) {
         pbf_writer::add_message(pbf_tag_type(tag), value);
     }
 
+    /**
+     * Add "message" field to data.
+     *
+     * @param tag Tag of the field
+     * @param value Value to be written. The value must be a complete message.
+     */
     void add_message(T tag, const std::string& value) {
         pbf_writer::add_message(pbf_tag_type(tag), value);
     }
diff --git a/third_party/protozero/include/protozero/pbf_message.hpp b/third_party/protozero/include/protozero/pbf_message.hpp
new file mode 100644
index 00000000000..10040d5b4e0
--- /dev/null
+++ b/third_party/protozero/include/protozero/pbf_message.hpp
@@ -0,0 +1,184 @@
+#ifndef PROTOZERO_PBF_MESSAGE_HPP
+#define PROTOZERO_PBF_MESSAGE_HPP
+
+/*****************************************************************************
+
+protozero - Minimalistic protocol buffer decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/protozero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file pbf_message.hpp
+ *
+ * @brief Contains the pbf_message template class.
+ */
+
+#include <protozero/pbf_reader.hpp>
+#include <protozero/types.hpp>
+
+#include <type_traits>
+
+namespace protozero {
+
+/**
+ * This class represents a protobuf message. Either a top-level message or
+ * a nested sub-message. Top-level messages can be created from any buffer
+ * with a pointer and length:
+ *
+ * @code
+ *    enum class Message : protozero::pbf_tag_type {
+ *       ...
+ *    };
+ *
+ *    std::string buffer;
+ *    // fill buffer...
+ *    pbf_message<Message> message{buffer.data(), buffer.size()};
+ * @endcode
+ *
+ * Sub-messages are created using get_message():
+ *
+ * @code
+ *    enum class SubMessage : protozero::pbf_tag_type {
+ *       ...
+ *    };
+ *
+ *    pbf_message<Message> message{...};
+ *    message.next();
+ *    pbf_message<SubMessage> submessage = message.get_message();
+ * @endcode
+ *
+ * All methods of the pbf_message class except get_bytes() and get_string()
+ * provide the strong exception guarantee, ie they either succeed or do not
+ * change the pbf_message object they are called on. Use the get_data() method
+ * instead of get_bytes() or get_string(), if you need this guarantee.
+ *
+ * This template class is based on the pbf_reader class and has all the same
+ * methods. The difference is that whereever the pbf_reader class takes an
+ * integer tag, this template class takes a tag of the template type T.
+ *
+ * Read the tutorial to understand how this class is used.
+ */
+template <typename T>
+class pbf_message : public pbf_reader {
+
+    static_assert(std::is_same<pbf_tag_type, typename std::underlying_type<T>::type>::value,
+                  "T must be enum with underlying type protozero::pbf_tag_type");
+
+public:
+
+    /// The type of messages this class will read.
+    using enum_type = T;
+
+    /**
+     * Construct a pbf_message. All arguments are forwarded to the pbf_reader
+     * parent class.
+     */
+    template <typename... Args>
+    pbf_message(Args&&... args) noexcept : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
+        pbf_reader(std::forward<Args>(args)...) {
+    }
+
+    /**
+     * Set next field in the message as the current field. This is usually
+     * called in a while loop:
+     *
+     * @code
+     *    pbf_message<...> message(...);
+     *    while (message.next()) {
+     *        // handle field
+     *    }
+     * @endcode
+     *
+     * @returns `true` if there is a next field, `false` if not.
+     * @pre There must be no current field.
+     * @post If it returns `true` there is a current field now.
+     */
+    bool next() {
+        return pbf_reader::next();
+    }
+
+    /**
+     * Set next field with given tag in the message as the current field.
+     * Fields with other tags are skipped. This is usually called in a while
+     * loop for repeated fields:
+     *
+     * @code
+     *    pbf_message<Example1> message{...};
+     *    while (message.next(Example1::repeated_fixed64_r)) {
+     *        // handle field
+     *    }
+     * @endcode
+     *
+     * or you can call it just once to get the one field with this tag:
+     *
+     * @code
+     *    pbf_message<Example1> message{...};
+     *    if (message.next(Example1::required_uint32_x)) {
+     *        // handle field
+     *    }
+     * @endcode
+     *
+     * Note that this will not check the wire type. The two-argument version
+     * of this function will also check the wire type.
+     *
+     * @returns `true` if there is a next field with this tag.
+     * @pre There must be no current field.
+     * @post If it returns `true` there is a current field now with the given tag.
+     */
+    bool next(T next_tag) {
+        return pbf_reader::next(pbf_tag_type(next_tag));
+    }
+
+    /**
+     * Set next field with given tag and wire type in the message as the
+     * current field. Fields with other tags are skipped. This is usually
+     * called in a while loop for repeated fields:
+     *
+     * @code
+     *    pbf_message<Example1> message{...};
+     *    while (message.next(Example1::repeated_fixed64_r, pbf_wire_type::varint)) {
+     *        // handle field
+     *    }
+     * @endcode
+     *
+     * or you can call it just once to get the one field with this tag:
+     *
+     * @code
+     *    pbf_message<Example1> message{...};
+     *    if (message.next(Example1::required_uint32_x, pbf_wire_type::varint)) {
+     *        // handle field
+     *    }
+     * @endcode
+     *
+     * Note that this will also check the wire type. The one-argument version
+     * of this function will not check the wire type.
+     *
+     * @returns `true` if there is a next field with this tag.
+     * @pre There must be no current field.
+     * @post If it returns `true` there is a current field now with the given tag.
+     */
+    bool next(T next_tag, pbf_wire_type type) {
+        return pbf_reader::next(pbf_tag_type(next_tag), type);
+    }
+
+    /**
+     * The tag of the current field. The tag is the enum value for the field
+     * number from the description in the .proto file.
+     *
+     * Call next() before calling this function to set the current field.
+     *
+     * @returns tag of the current field.
+     * @pre There must be a current field (ie. next() must have returned `true`).
+     */
+    T tag() const noexcept {
+        return T(pbf_reader::tag());
+    }
+
+}; // class pbf_message
+
+} // end namespace protozero
+
+#endif // PROTOZERO_PBF_MESSAGE_HPP
diff --git a/third_party/libosmium/include/protozero/pbf_reader.hpp b/third_party/protozero/include/protozero/pbf_reader.hpp
similarity index 91%
rename from third_party/libosmium/include/protozero/pbf_reader.hpp
rename to third_party/protozero/include/protozero/pbf_reader.hpp
index 905ca0aad07..5f8ea0ecac4 100644
--- a/third_party/libosmium/include/protozero/pbf_reader.hpp
+++ b/third_party/protozero/include/protozero/pbf_reader.hpp
@@ -16,12 +16,8 @@ documentation.
  * @brief Contains the pbf_reader class.
  */
 
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <utility>
-
 #include <protozero/config.hpp>
+#include <protozero/data_view.hpp>
 #include <protozero/exception.hpp>
 #include <protozero/iterators.hpp>
 #include <protozero/types.hpp>
@@ -31,6 +27,12 @@ documentation.
 # include <protozero/byteswap.hpp>
 #endif
 
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <utility>
+
 namespace protozero {
 
 /**
@@ -41,13 +43,13 @@ namespace protozero {
  * @code
  *    std::string buffer;
  *    // fill buffer...
- *    pbf_reader message(buffer.data(), buffer.size());
+ *    pbf_reader message{buffer.data(), buffer.size()};
  * @endcode
  *
  * Sub-messages are created using get_message():
  *
  * @code
- *    pbf_reader message(...);
+ *    pbf_reader message{...};
  *    message.next();
  *    pbf_reader submessage = message.get_message();
  * @endcode
@@ -74,8 +76,9 @@ class pbf_reader {
     template <typename T>
     T get_fixed() {
         T result;
+        const char* data = m_data;
         skip_bytes(sizeof(T));
-        std::memcpy(&result, m_data - sizeof(T), sizeof(T));
+        std::memcpy(&result, data, sizeof(T));
 #if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN
         detail::byteswap_inplace(&result);
 #endif
@@ -86,9 +89,11 @@ class pbf_reader {
     iterator_range<const_fixed_iterator<T>> packed_fixed() {
         protozero_assert(tag() != 0 && "call next() before accessing field value");
         const auto len = get_len_and_skip();
-        protozero_assert(len % sizeof(T) == 0);
-        return iterator_range<const_fixed_iterator<T>>{const_fixed_iterator<T>(m_data - len, m_data),
-                                                       const_fixed_iterator<T>(m_data, m_data)};
+        if (len % sizeof(T) != 0) {
+            throw invalid_length_exception{};
+        }
+        return {const_fixed_iterator<T>(m_data - len),
+                const_fixed_iterator<T>(m_data)};
     }
 
     template <typename T>
@@ -108,13 +113,13 @@ class pbf_reader {
 
     void skip_bytes(pbf_length_type len) {
         if (m_data + len > m_end) {
-            throw end_of_buffer_exception();
+            throw end_of_buffer_exception{};
         }
         m_data += len;
 
-    // In debug builds reset the tag to zero so that we can detect (some)
-    // wrong code.
 #ifndef NDEBUG
+        // In debug builds reset the tag to zero so that we can detect (some)
+        // wrong code.
         m_tag = 0;
 #endif
     }
@@ -129,8 +134,8 @@ class pbf_reader {
     iterator_range<T> get_packed() {
         protozero_assert(tag() != 0 && "call next() before accessing field value");
         const auto len = get_len_and_skip();
-        return iterator_range<T>{T{m_data - len, m_data},
-                                 T{m_data, m_data}};
+        return {T{m_data - len, m_data},
+                T{m_data, m_data}};
     }
 
 public:
@@ -147,9 +152,7 @@ class pbf_reader {
      */
     explicit pbf_reader(const data_view& view) noexcept
         : m_data(view.data()),
-          m_end(view.data() + view.size()),
-          m_wire_type(pbf_wire_type::unknown),
-          m_tag(0) {
+          m_end(view.data() + view.size()) {
     }
 
     /**
@@ -164,11 +167,10 @@ class pbf_reader {
      */
     pbf_reader(const char* data, std::size_t size) noexcept
         : m_data(data),
-          m_end(data + size),
-          m_wire_type(pbf_wire_type::unknown),
-          m_tag(0) {
+          m_end(data + size) {
     }
 
+#ifndef PROTOZERO_STRICT_API
     /**
      * Construct a pbf_reader message from a data pointer and a length. The
      * pointer will be stored inside the pbf_reader object, no data is copied.
@@ -178,13 +180,13 @@ class pbf_reader {
      * The buffer must contain a complete protobuf message.
      *
      * @post There is no current field.
+     * @deprecated Use one of the other constructors.
      */
     explicit pbf_reader(const std::pair<const char*, std::size_t>& data) noexcept
         : m_data(data.first),
-          m_end(data.first + data.second),
-          m_wire_type(pbf_wire_type::unknown),
-          m_tag(0) {
+          m_end(data.first + data.second) {
     }
+#endif
 
     /**
      * Construct a pbf_reader message from a std::string. A pointer to the
@@ -198,9 +200,7 @@ class pbf_reader {
      */
     explicit pbf_reader(const std::string& data) noexcept
         : m_data(data.data()),
-          m_end(data.data() + data.size()),
-          m_wire_type(pbf_wire_type::unknown),
-          m_tag(0) {
+          m_end(data.data() + data.size()) {
     }
 
     /**
@@ -241,7 +241,7 @@ class pbf_reader {
      * are still fields available and to `false` if the last field has been
      * read.
      */
-    operator bool() const noexcept {
+    operator bool() const noexcept { // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
         return m_data < m_end;
     }
 
@@ -279,14 +279,15 @@ class pbf_reader {
         }
 
         const auto value = get_varint<uint32_t>();
-        m_tag = pbf_tag_type(value >> 3);
+        m_tag = pbf_tag_type(value >> 3u);
 
         // tags 0 and 19000 to 19999 are not allowed as per
-        // https://developers.google.com/protocol-buffers/docs/proto
-        protozero_assert(((m_tag >     0 && m_tag < 19000) ||
-                          (m_tag > 19999 && m_tag <= ((1 << 29) - 1))) && "tag out of range");
+        // https://developers.google.com/protocol-buffers/docs/proto#assigning-tags
+        if (m_tag == 0 || (m_tag >= 19000 && m_tag <= 19999)) {
+            throw invalid_tag_exception{};
+        }
 
-        m_wire_type = pbf_wire_type(value & 0x07);
+        m_wire_type = pbf_wire_type(value & 0x07u);
         switch (m_wire_type) {
             case pbf_wire_type::varint:
             case pbf_wire_type::fixed64:
@@ -294,7 +295,7 @@ class pbf_reader {
             case pbf_wire_type::fixed32:
                 break;
             default:
-                throw unknown_pbf_wire_type_exception();
+                throw unknown_pbf_wire_type_exception{};
         }
 
         return true;
@@ -306,7 +307,7 @@ class pbf_reader {
      * loop for repeated fields:
      *
      * @code
-     *    pbf_reader message(...);
+     *    pbf_reader message{...};
      *    while (message.next(17)) {
      *        // handle field
      *    }
@@ -315,7 +316,7 @@ class pbf_reader {
      * or you can call it just once to get the one field with this tag:
      *
      * @code
-     *    pbf_reader message(...);
+     *    pbf_reader message{...};
      *    if (message.next(17)) {
      *        // handle field
      *    }
@@ -332,9 +333,8 @@ class pbf_reader {
         while (next()) {
             if (m_tag == next_tag) {
                 return true;
-            } else {
-                skip();
             }
+            skip();
         }
         return false;
     }
@@ -345,7 +345,7 @@ class pbf_reader {
      * called in a while loop for repeated fields:
      *
      * @code
-     *    pbf_reader message(...);
+     *    pbf_reader message{...};
      *    while (message.next(17, pbf_wire_type::varint)) {
      *        // handle field
      *    }
@@ -354,7 +354,7 @@ class pbf_reader {
      * or you can call it just once to get the one field with this tag:
      *
      * @code
-     *    pbf_reader message(...);
+     *    pbf_reader message{...};
      *    if (message.next(17, pbf_wire_type::varint)) {
      *        // handle field
      *    }
@@ -371,9 +371,8 @@ class pbf_reader {
         while (next()) {
             if (m_tag == next_tag && m_wire_type == type) {
                 return true;
-            } else {
-                skip();
             }
+            skip();
         }
         return false;
     }
@@ -417,7 +416,7 @@ class pbf_reader {
      * Use it like this:
      *
      * @code
-     *    pbf_reader message(...);
+     *    pbf_reader message{...};
      *    while (message.next()) {
      *        switch (message.tag_and_type()) {
      *            case tag_and_type(17, pbf_wire_type::length_delimited):
@@ -468,7 +467,7 @@ class pbf_reader {
                 skip_bytes(4);
                 break;
             default:
-                protozero_assert(false && "can not be here because next() should have thrown already");
+                break;
         }
     }
 
@@ -487,9 +486,9 @@ class pbf_reader {
     bool get_bool() {
         protozero_assert(tag() != 0 && "call next() before accessing field value");
         protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
-        protozero_assert((*m_data & 0x80) == 0 && "not a 1 byte varint");
-        skip_bytes(1);
-        return m_data[-1] != 0; // -1 okay because we incremented m_data the line before
+        const auto data = m_data;
+        skip_varint(&m_data, m_end);
+        return data[0] != 0;
     }
 
     /**
@@ -667,7 +666,7 @@ class pbf_reader {
         protozero_assert(tag() != 0 && "call next() before accessing field value");
         protozero_assert(has_wire_type(pbf_wire_type::length_delimited) && "not of type string, bytes or message");
         const auto len = get_len_and_skip();
-        return data_view{m_data - len, len};
+        return {m_data - len, len};
     }
 
 #ifndef PROTOZERO_STRICT_API
@@ -683,7 +682,7 @@ class pbf_reader {
         protozero_assert(tag() != 0 && "call next() before accessing field value");
         protozero_assert(has_wire_type(pbf_wire_type::length_delimited) && "not of type string, bytes or message");
         const auto len = get_len_and_skip();
-        return std::make_pair(m_data - len, len);
+        return {m_data - len, len};
     }
 #endif
 
@@ -717,7 +716,7 @@ class pbf_reader {
      * @post The current field was consumed and there is no current field now.
      */
     pbf_reader get_message() {
-        return pbf_reader(get_view());
+        return pbf_reader{get_view()};
     }
 
     ///@}
@@ -746,6 +745,24 @@ class pbf_reader {
     /// Forward iterator for iterating over uint64 (varint) values.
     using const_uint64_iterator = const_varint_iterator<uint64_t>;
 
+    /// Forward iterator for iterating over fixed32 values.
+    using const_fixed32_iterator = const_fixed_iterator<uint32_t>;
+
+    /// Forward iterator for iterating over sfixed32 values.
+    using const_sfixed32_iterator = const_fixed_iterator<int32_t>;
+
+    /// Forward iterator for iterating over fixed64 values.
+    using const_fixed64_iterator = const_fixed_iterator<uint64_t>;
+
+    /// Forward iterator for iterating over sfixed64 values.
+    using const_sfixed64_iterator = const_fixed_iterator<int64_t>;
+
+    /// Forward iterator for iterating over float values.
+    using const_float_iterator = const_fixed_iterator<float>;
+
+    /// Forward iterator for iterating over double values.
+    using const_double_iterator = const_fixed_iterator<double>;
+
     ///@{
     /**
      * @name Repeated packed field accessor functions
@@ -864,7 +881,7 @@ class pbf_reader {
      * @pre The current field must be of type "repeated packed fixed32".
      * @post The current field was consumed and there is no current field now.
      */
-    auto get_packed_fixed32() -> decltype(packed_fixed<uint32_t>()) {
+    iterator_range<pbf_reader::const_fixed32_iterator> get_packed_fixed32() {
         return packed_fixed<uint32_t>();
     }
 
@@ -877,7 +894,7 @@ class pbf_reader {
      * @pre The current field must be of type "repeated packed sfixed32".
      * @post The current field was consumed and there is no current field now.
      */
-    auto get_packed_sfixed32() -> decltype(packed_fixed<int32_t>()) {
+    iterator_range<pbf_reader::const_sfixed32_iterator> get_packed_sfixed32() {
         return packed_fixed<int32_t>();
     }
 
@@ -890,7 +907,7 @@ class pbf_reader {
      * @pre The current field must be of type "repeated packed fixed64".
      * @post The current field was consumed and there is no current field now.
      */
-    auto get_packed_fixed64() -> decltype(packed_fixed<uint64_t>()) {
+    iterator_range<pbf_reader::const_fixed64_iterator> get_packed_fixed64() {
         return packed_fixed<uint64_t>();
     }
 
@@ -903,7 +920,7 @@ class pbf_reader {
      * @pre The current field must be of type "repeated packed sfixed64".
      * @post The current field was consumed and there is no current field now.
      */
-    auto get_packed_sfixed64() -> decltype(packed_fixed<int64_t>()) {
+    iterator_range<pbf_reader::const_sfixed64_iterator> get_packed_sfixed64() {
         return packed_fixed<int64_t>();
     }
 
@@ -916,7 +933,7 @@ class pbf_reader {
      * @pre The current field must be of type "repeated packed float".
      * @post The current field was consumed and there is no current field now.
      */
-    auto get_packed_float() -> decltype(packed_fixed<float>()) {
+    iterator_range<pbf_reader::const_float_iterator> get_packed_float() {
         return packed_fixed<float>();
     }
 
@@ -929,7 +946,7 @@ class pbf_reader {
      * @pre The current field must be of type "repeated packed double".
      * @post The current field was consumed and there is no current field now.
      */
-    auto get_packed_double() -> decltype(packed_fixed<double>()) {
+    iterator_range<pbf_reader::const_double_iterator> get_packed_double() {
         return packed_fixed<double>();
     }
 
diff --git a/third_party/libosmium/include/protozero/pbf_writer.hpp b/third_party/protozero/include/protozero/pbf_writer.hpp
similarity index 89%
rename from third_party/libosmium/include/protozero/pbf_writer.hpp
rename to third_party/protozero/include/protozero/pbf_writer.hpp
index af626bd99c7..1abe9a38a44 100644
--- a/third_party/libosmium/include/protozero/pbf_writer.hpp
+++ b/third_party/protozero/include/protozero/pbf_writer.hpp
@@ -16,15 +16,8 @@ documentation.
  * @brief Contains the pbf_writer class.
  */
 
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-#include <limits>
-#include <string>
-#include <utility>
-
 #include <protozero/config.hpp>
+#include <protozero/data_view.hpp>
 #include <protozero/types.hpp>
 #include <protozero/varint.hpp>
 
@@ -32,6 +25,15 @@ documentation.
 # include <protozero/byteswap.hpp>
 #endif
 
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <string>
+#include <utility>
+
 namespace protozero {
 
 namespace detail {
@@ -53,11 +55,11 @@ class pbf_writer {
     // A pointer to a string buffer holding the data already written to the
     // PBF message. For default constructed writers or writers that have been
     // rolled back, this is a nullptr.
-    std::string* m_data;
+    std::string* m_data = nullptr;
 
     // A pointer to a parent writer object if this is a submessage. If this
     // is a top-level writer, it is a nullptr.
-    pbf_writer* m_parent_writer;
+    pbf_writer* m_parent_writer = nullptr;
 
     // This is usually 0. If there is an open submessage, this is set in the
     // parent to the rollback position, ie. the last position before the
@@ -76,8 +78,8 @@ class pbf_writer {
     }
 
     void add_field(pbf_tag_type tag, pbf_wire_type type) {
-        protozero_assert(((tag > 0 && tag < 19000) || (tag > 19999 && tag <= ((1 << 29) - 1))) && "tag out of range");
-        const uint32_t b = (tag << 3) | uint32_t(type);
+        protozero_assert(((tag > 0 && tag < 19000) || (tag > 19999 && tag <= ((1u << 29u) - 1))) && "tag out of range");
+        const uint32_t b = (tag << 3u) | uint32_t(type);
         add_varint(b);
     }
 
@@ -97,12 +99,12 @@ class pbf_writer {
     }
 
     template <typename T, typename It>
-    void add_packed_fixed(pbf_tag_type tag, It first, It last, std::input_iterator_tag) {
+    void add_packed_fixed(pbf_tag_type tag, It first, It last, std::input_iterator_tag /*unused*/) {
         if (first == last) {
             return;
         }
 
-        pbf_writer sw(*this, tag);
+        pbf_writer sw{*this, tag};
 
         while (first != last) {
             sw.add_fixed<T>(*first++);
@@ -110,7 +112,7 @@ class pbf_writer {
     }
 
     template <typename T, typename It>
-    void add_packed_fixed(pbf_tag_type tag, It first, It last, std::forward_iterator_tag) {
+    void add_packed_fixed(pbf_tag_type tag, It first, It last, std::forward_iterator_tag /*unused*/) {
         if (first == last) {
             return;
         }
@@ -130,7 +132,7 @@ class pbf_writer {
             return;
         }
 
-        pbf_writer sw(*this, tag);
+        pbf_writer sw{*this, tag};
 
         while (first != last) {
             sw.add_varint(uint64_t(*first++));
@@ -143,7 +145,7 @@ class pbf_writer {
             return;
         }
 
-        pbf_writer sw(*this, tag);
+        pbf_writer sw{*this, tag};
 
         while (first != last) {
             sw.add_varint(encode_zigzag64(*first++));
@@ -194,9 +196,9 @@ class pbf_writer {
         const auto length = pbf_length_type(m_data->size() - m_pos);
 
         protozero_assert(m_data->size() >= m_pos - reserve_bytes);
-        const auto n = write_varint(m_data->begin() + long(m_pos) - reserve_bytes, length);
+        const auto n = write_varint(m_data->begin() + int64_t(m_pos) - reserve_bytes, length);
 
-        m_data->erase(m_data->begin() + long(m_pos) - reserve_bytes + n, m_data->begin() + long(m_pos));
+        m_data->erase(m_data->begin() + int64_t(m_pos) - reserve_bytes + n, m_data->begin() + int64_t(m_pos));
         m_pos = 0;
     }
 
@@ -225,18 +227,14 @@ class pbf_writer {
      * doesn't have to be empty. The pbf_writer will just append data.
      */
     explicit pbf_writer(std::string& data) noexcept :
-        m_data(&data),
-        m_parent_writer(nullptr) {
+        m_data(&data) {
     }
 
     /**
      * Create a writer without a data store. In this form the writer can not
      * be used!
      */
-    pbf_writer() noexcept :
-        m_data(nullptr),
-        m_parent_writer(nullptr) {
-    }
+    pbf_writer() noexcept = default;
 
     /**
      * Construct a pbf_writer for a submessage from the pbf_writer of the
@@ -254,24 +252,58 @@ class pbf_writer {
         m_parent_writer->open_submessage(tag, size);
     }
 
-    /// A pbf_writer object can be copied
-    pbf_writer(const pbf_writer&) noexcept = default;
+    /// A pbf_writer object can not be copied
+    pbf_writer(const pbf_writer&) = delete;
 
-    /// A pbf_writer object can be copied
-    pbf_writer& operator=(const pbf_writer&) noexcept = default;
+    /// A pbf_writer object can not be copied
+    pbf_writer& operator=(const pbf_writer&) = delete;
 
-    /// A pbf_writer object can be moved
-    pbf_writer(pbf_writer&&) noexcept = default;
+    /**
+     * A pbf_writer object can be moved. After this the other pbf_writer will
+     * be invalid.
+     */
+    pbf_writer(pbf_writer&& other) noexcept :
+        m_data(other.m_data),
+        m_parent_writer(other.m_parent_writer),
+        m_rollback_pos(other.m_rollback_pos),
+        m_pos(other.m_pos) {
+        other.m_data = nullptr;
+        other.m_parent_writer = nullptr;
+        other.m_rollback_pos = 0;
+        other.m_pos = 0;
+    }
 
-    /// A pbf_writer object can be moved
-    pbf_writer& operator=(pbf_writer&&) noexcept = default;
+    /**
+     * A pbf_writer object can be moved. After this the other pbf_writer will
+     * be invalid.
+     */
+    pbf_writer& operator=(pbf_writer&& other) noexcept {
+        m_data = other.m_data;
+        m_parent_writer = other.m_parent_writer;
+        m_rollback_pos = other.m_rollback_pos;
+        m_pos = other.m_pos;
+        other.m_data = nullptr;
+        other.m_parent_writer = nullptr;
+        other.m_rollback_pos = 0;
+        other.m_pos = 0;
+        return *this;
+    }
 
     ~pbf_writer() {
-        if (m_parent_writer) {
+        if (m_parent_writer != nullptr) {
             m_parent_writer->close_submessage();
         }
     }
 
+    /**
+     * Check if this writer is valid. A writer is invalid if it was default
+     * constructed, moved from, or if commit() has been called on it.
+     * Otherwise it is valid.
+     */
+    bool valid() const noexcept {
+        return m_data != nullptr;
+    }
+
     /**
      * Swap the contents of this object with the other.
      *
@@ -298,17 +330,35 @@ class pbf_writer {
         m_data->reserve(m_data->size() + size);
     }
 
+    /**
+     * Commit this submessage. This does the same as when the pbf_writer
+     * goes out of scope and is destructed.
+     *
+     * @pre Must be a pbf_writer of a submessage, ie one opened with the
+     *      pbf_writer constructor taking a parent message.
+     * @post The pbf_writer is invalid and can't be used any more.
+     */
+    void commit() {
+        protozero_assert(m_parent_writer && "you can't call commit() on a pbf_writer without a parent");
+        protozero_assert(m_pos == 0 && "you can't call commit() on a pbf_writer that has an open nested submessage");
+        m_parent_writer->close_submessage();
+        m_parent_writer = nullptr;
+        m_data = nullptr;
+    }
+
     /**
      * Cancel writing of this submessage. The complete submessage will be
      * removed as if it was never created and no fields were added.
      *
      * @pre Must be a pbf_writer of a submessage, ie one opened with the
      *      pbf_writer constructor taking a parent message.
+     * @post The pbf_writer is invalid and can't be used any more.
      */
     void rollback() {
         protozero_assert(m_parent_writer && "you can't call rollback() on a pbf_writer without a parent");
         protozero_assert(m_pos == 0 && "you can't call rollback() on a pbf_writer that has an open nested submessage");
         m_parent_writer->rollback_submessage();
+        m_parent_writer = nullptr;
         m_data = nullptr;
     }
 
@@ -327,7 +377,7 @@ class pbf_writer {
         add_field(tag, pbf_wire_type::varint);
         protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
         protozero_assert(m_data);
-        m_data->append(1, value);
+        m_data->append(1, char(value));
     }
 
     /**
@@ -849,15 +899,17 @@ namespace detail {
 
     protected:
 
-        pbf_writer m_writer;
+        pbf_writer m_writer{};
 
     public:
 
         packed_field(const packed_field&) = delete;
         packed_field& operator=(const packed_field&) = delete;
 
-        packed_field(packed_field&&) = default;
-        packed_field& operator=(packed_field&&) = default;
+        packed_field(packed_field&&) noexcept = default;
+        packed_field& operator=(packed_field&&) noexcept = default;
+
+        packed_field() = default;
 
         packed_field(pbf_writer& parent_writer, pbf_tag_type tag) :
             m_writer(parent_writer, tag) {
@@ -867,6 +919,16 @@ namespace detail {
             m_writer(parent_writer, tag, size) {
         }
 
+        ~packed_field() noexcept = default;
+
+        bool valid() const noexcept {
+            return m_writer.valid();
+        }
+
+        void commit() {
+            m_writer.commit();
+        }
+
         void rollback() {
             m_writer.rollback();
         }
@@ -878,6 +940,10 @@ namespace detail {
 
     public:
 
+        packed_field_fixed() :
+            packed_field() {
+        }
+
         template <typename P>
         packed_field_fixed(pbf_writer& parent_writer, P tag) :
             packed_field(parent_writer, static_cast<pbf_tag_type>(tag)) {
@@ -899,6 +965,10 @@ namespace detail {
 
     public:
 
+        packed_field_varint() :
+            packed_field() {
+        }
+
         template <typename P>
         packed_field_varint(pbf_writer& parent_writer, P tag) :
             packed_field(parent_writer, static_cast<pbf_tag_type>(tag)) {
@@ -915,6 +985,10 @@ namespace detail {
 
     public:
 
+        packed_field_svarint() :
+            packed_field() {
+        }
+
         template <typename P>
         packed_field_svarint(pbf_writer& parent_writer, P tag) :
             packed_field(parent_writer, static_cast<pbf_tag_type>(tag)) {
diff --git a/third_party/protozero/include/protozero/types.hpp b/third_party/protozero/include/protozero/types.hpp
new file mode 100644
index 00000000000..b5241274e38
--- /dev/null
+++ b/third_party/protozero/include/protozero/types.hpp
@@ -0,0 +1,66 @@
+#ifndef PROTOZERO_TYPES_HPP
+#define PROTOZERO_TYPES_HPP
+
+/*****************************************************************************
+
+protozero - Minimalistic protocol buffer decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/protozero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file types.hpp
+ *
+ * @brief Contains the declaration of low-level types used in the pbf format.
+ */
+
+#include <protozero/config.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <utility>
+
+namespace protozero {
+
+/**
+ * The type used for field tags (field numbers).
+ */
+using pbf_tag_type = uint32_t;
+
+/**
+ * The type used to encode type information.
+ * See the table on
+ *    https://developers.google.com/protocol-buffers/docs/encoding
+ */
+enum class pbf_wire_type : uint32_t {
+    varint           = 0, // int32/64, uint32/64, sint32/64, bool, enum
+    fixed64          = 1, // fixed64, sfixed64, double
+    length_delimited = 2, // string, bytes, nested messages, packed repeated fields
+    fixed32          = 5, // fixed32, sfixed32, float
+    unknown          = 99 // used for default setting in this library
+};
+
+/**
+ * Get the tag and wire type of the current field in one integer suitable
+ * for comparison with a switch statement.
+ *
+ * See pbf_reader.tag_and_type() for an example how to use this.
+ */
+template <typename T>
+constexpr inline uint32_t tag_and_type(T tag, pbf_wire_type wire_type) noexcept {
+    return (static_cast<uint32_t>(static_cast<pbf_tag_type>(tag)) << 3u) | static_cast<uint32_t>(wire_type);
+}
+
+/**
+ * The type used for length values, such as the length of a field.
+ */
+using pbf_length_type = uint32_t;
+
+} // end namespace protozero
+
+#endif // PROTOZERO_TYPES_HPP
diff --git a/third_party/libosmium/include/protozero/varint.hpp b/third_party/protozero/include/protozero/varint.hpp
similarity index 67%
rename from third_party/libosmium/include/protozero/varint.hpp
rename to third_party/protozero/include/protozero/varint.hpp
index d115d5fddcb..dd79a6ef9d5 100644
--- a/third_party/libosmium/include/protozero/varint.hpp
+++ b/third_party/protozero/include/protozero/varint.hpp
@@ -16,10 +16,10 @@ documentation.
  * @brief Contains low-level varint and zigzag encoding and decoding functions.
  */
 
-#include <cstdint>
-
 #include <protozero/exception.hpp>
 
+#include <cstdint>
+
 namespace protozero {
 
 /**
@@ -31,34 +31,34 @@ namespace detail {
 
     // from https://github.com/facebook/folly/blob/master/folly/Varint.h
     inline uint64_t decode_varint_impl(const char** data, const char* end) {
-        const int8_t* begin = reinterpret_cast<const int8_t*>(*data);
-        const int8_t* iend = reinterpret_cast<const int8_t*>(end);
+        const auto begin = reinterpret_cast<const int8_t*>(*data);
+        const auto iend = reinterpret_cast<const int8_t*>(end);
         const int8_t* p = begin;
         uint64_t val = 0;
 
         if (iend - begin >= max_varint_length) {  // fast path
             do {
                 int64_t b;
-                b = *p++; val  = uint64_t((b & 0x7f)      ); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) <<  7); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 14); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 21); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 28); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 35); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 42); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 49); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 56); if (b >= 0) break;
-                b = *p++; val |= uint64_t((b & 0x7f) << 63); if (b >= 0) break;
-                throw varint_too_long_exception();
+                b = *p++; val  = uint64_t((b & 0x7fu)       ); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) <<  7u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) << 14u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) << 21u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) << 28u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) << 35u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) << 42u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) << 49u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x7fu) << 56u); if (b >= 0) { break; }
+                b = *p++; val |= uint64_t((b & 0x01u) << 63u); if (b >= 0) { break; }
+                throw varint_too_long_exception{};
             } while (false);
         } else {
-            int shift = 0;
+            unsigned int shift = 0;
             while (p != iend && *p < 0) {
-                val |= uint64_t(*p++ & 0x7f) << shift;
+                val |= uint64_t(*p++ & 0x7fu) << shift;
                 shift += 7;
             }
             if (p == iend) {
-                throw end_of_buffer_exception();
+                throw end_of_buffer_exception{};
             }
             val |= uint64_t(*p++) << shift;
         }
@@ -88,8 +88,8 @@ namespace detail {
  */
 inline uint64_t decode_varint(const char** data, const char* end) {
     // If this is a one-byte varint, decode it here.
-    if (end != *data && ((**data & 0x80) == 0)) {
-        uint64_t val = uint64_t(**data);
+    if (end != *data && ((**data & 0x80u) == 0)) {
+        const auto val = static_cast<uint64_t>(**data);
         ++(*data);
         return val;
     }
@@ -110,8 +110,8 @@ inline uint64_t decode_varint(const char** data, const char* end) {
  *         before the end of the varint.
  */
 inline void skip_varint(const char** data, const char* end) {
-    const int8_t* begin = reinterpret_cast<const int8_t*>(*data);
-    const int8_t* iend = reinterpret_cast<const int8_t*>(end);
+    const auto begin = reinterpret_cast<const int8_t*>(*data);
+    const auto iend = reinterpret_cast<const int8_t*>(end);
     const int8_t* p = begin;
 
     while (p != iend && *p < 0) {
@@ -119,11 +119,11 @@ inline void skip_varint(const char** data, const char* end) {
     }
 
     if (p >= begin + max_varint_length) {
-        throw varint_too_long_exception();
+        throw varint_too_long_exception{};
     }
 
     if (p == iend) {
-        throw end_of_buffer_exception();
+        throw end_of_buffer_exception{};
     }
 
     ++p;
@@ -138,15 +138,16 @@ inline void skip_varint(const char** data, const char* end) {
  * @param data Output iterator the varint encoded value will be written to
  *             byte by byte.
  * @param value The integer that will be encoded.
+ * @returns the number of bytes written
  * @throws Any exception thrown by increment or dereference operator on data.
  */
 template <typename T>
 inline int write_varint(T data, uint64_t value) {
     int n = 1;
 
-    while (value >= 0x80) {
-        *data++ = char((value & 0x7f) | 0x80);
-        value >>= 7;
+    while (value >= 0x80u) {
+        *data++ = char((value & 0x7fu) | 0x80u);
+        value >>= 7u;
         ++n;
     }
     *data++ = char(value);
@@ -158,28 +159,28 @@ inline int write_varint(T data, uint64_t value) {
  * ZigZag encodes a 32 bit integer.
  */
 inline constexpr uint32_t encode_zigzag32(int32_t value) noexcept {
-    return (static_cast<uint32_t>(value) << 1) ^ (static_cast<uint32_t>(value >> 31));
+    return (static_cast<uint32_t>(value) << 1u) ^ (static_cast<uint32_t>(value >> 31u));
 }
 
 /**
  * ZigZag encodes a 64 bit integer.
  */
 inline constexpr uint64_t encode_zigzag64(int64_t value) noexcept {
-    return (static_cast<uint64_t>(value) << 1) ^ (static_cast<uint64_t>(value >> 63));
+    return (static_cast<uint64_t>(value) << 1u) ^ (static_cast<uint64_t>(value >> 63u));
 }
 
 /**
  * Decodes a 32 bit ZigZag-encoded integer.
  */
 inline constexpr int32_t decode_zigzag32(uint32_t value) noexcept {
-    return static_cast<int32_t>(value >> 1) ^ -static_cast<int32_t>(value & 1);
+    return static_cast<int32_t>(value >> 1u) ^ -static_cast<int32_t>(value & 1u);
 }
 
 /**
  * Decodes a 64 bit ZigZag-encoded integer.
  */
 inline constexpr int64_t decode_zigzag64(uint64_t value) noexcept {
-    return static_cast<int64_t>(value >> 1) ^ -static_cast<int64_t>(value & 1);
+    return static_cast<int64_t>(value >> 1u) ^ -static_cast<int64_t>(value & 1u);
 }
 
 } // end namespace protozero
diff --git a/third_party/libosmium/include/protozero/version.hpp b/third_party/protozero/include/protozero/version.hpp
similarity index 91%
rename from third_party/libosmium/include/protozero/version.hpp
rename to third_party/protozero/include/protozero/version.hpp
index 6d828236ff6..32a494f4b6b 100644
--- a/third_party/libosmium/include/protozero/version.hpp
+++ b/third_party/protozero/include/protozero/version.hpp
@@ -20,7 +20,7 @@ documentation.
 #define PROTOZERO_VERSION_MAJOR 1
 
 /// The minor version number
-#define PROTOZERO_VERSION_MINOR 5
+#define PROTOZERO_VERSION_MINOR 6
 
 /// The patch number
 #define PROTOZERO_VERSION_PATCH 2
@@ -29,6 +29,6 @@ documentation.
 #define PROTOZERO_VERSION_CODE (PROTOZERO_VERSION_MAJOR * 10000 + PROTOZERO_VERSION_MINOR * 100 + PROTOZERO_VERSION_PATCH)
 
 /// Version number as string
-#define PROTOZERO_VERSION_STRING "1.5.2"
+#define PROTOZERO_VERSION_STRING "1.6.2"
 
 #endif // PROTOZERO_VERSION_HPP
diff --git a/third_party/protozero/test/CMakeLists.txt b/third_party/protozero/test/CMakeLists.txt
new file mode 100644
index 00000000000..c7691235145
--- /dev/null
+++ b/third_party/protozero/test/CMakeLists.txt
@@ -0,0 +1,116 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake config
+#
+#  protozero tests
+#
+#-----------------------------------------------------------------------------
+
+include_directories(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/catch")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include")
+
+add_subdirectory(unit)
+
+set(TEST_DIRS alignment
+              bool
+              bytes
+              complex
+              double
+              enum
+              fixed32
+              fixed64
+              float
+              int32
+              int64
+              message
+              nested
+              repeated
+              repeated_packed_bool
+              repeated_packed_double
+              repeated_packed_enum
+              repeated_packed_fixed32
+              repeated_packed_fixed64
+              repeated_packed_float
+              repeated_packed_int32
+              repeated_packed_int64
+              repeated_packed_sfixed32
+              repeated_packed_sfixed64
+              repeated_packed_sint32
+              repeated_packed_sint64
+              repeated_packed_uint32
+              repeated_packed_uint64
+              rollback
+              sfixed32
+              sfixed64
+              sint32
+              sint64
+              skip
+              string
+              tag_and_type
+              tags
+              uint32
+              uint64
+              vector_tile
+              wrong_type_access)
+
+string(REGEX REPLACE "([^;]+)" "t/\\1/reader_test_cases.cpp" _test_sources "${TEST_DIRS}")
+
+add_executable(reader_tests reader_tests.cpp ${_test_sources})
+
+add_test(NAME reader_tests COMMAND reader_tests)
+
+set_tests_properties(reader_tests PROPERTIES WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
+
+if(PROTOBUF_FOUND)
+    message(STATUS "Found protobuf libraries: Adding writer tests...")
+
+    include_directories(SYSTEM ${PROTOBUF_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+
+    set(PROTOBUF_GENERATE_CPP_APPEND_PATH false)
+
+    foreach(_dir IN LISTS TEST_DIRS)
+        set(_full_src_dir "${CMAKE_CURRENT_SOURCE_DIR}/t/${_dir}")
+        if(EXISTS "${_full_src_dir}/writer_test_cases.cpp")
+            message(STATUS "  Adding ${_dir}")
+            set(_full_bin_dir "${CMAKE_CURRENT_BINARY_DIR}/t/${_dir}")
+            set(_proto_file "${_full_src_dir}/${_dir}_testcase.proto")
+            set(_src_file "${_full_bin_dir}/${_dir}_testcase.pb.cc")
+            set(_hdr_file "${_full_bin_dir}/${_dir}_testcase.pb.h")
+
+            file(MAKE_DIRECTORY ${_full_bin_dir})
+
+            list(APPEND SOURCES     "${_full_src_dir}/writer_test_cases.cpp")
+            list(APPEND PROTO_FILES "${_proto_file}")
+            list(APPEND PROTO_SRCS  "${_src_file}")
+            list(APPEND PROTO_HDRS  "${_hdr_file}")
+
+            set_source_files_properties(${_proto_file} ${_hdr_file}
+                                        PROPERTIES GENERATED TRUE)
+
+            add_custom_command(
+                OUTPUT ${_src_file} ${_hdr_file}
+                COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+                ARGS --cpp_out=${_full_bin_dir} -I ${_full_src_dir} ${_proto_file}
+                DEPENDS ${_proto_file}
+                VERBATIM)
+        endif()
+    endforeach()
+
+    add_executable(writer_tests writer_tests.cpp ${SOURCES} ${PROTO_SRCS} ${PROTO_HDRS})
+
+    target_link_libraries(writer_tests ${PROTOBUF_LITE_LIBRARY})
+
+    if(NOT MSVC)
+        set_target_properties(writer_tests PROPERTIES COMPILE_FLAGS "-pthread")
+        if(NOT APPLE)
+            set_target_properties(writer_tests PROPERTIES LINK_FLAGS "-pthread")
+        endif()
+    endif()
+
+    add_test(NAME writer_tests COMMAND writer_tests)
+else()
+    message(STATUS "Protobuf libraries not found: Disabling writer tests.")
+endif()
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/protozero/test/README.md b/third_party/protozero/test/README.md
new file mode 100644
index 00000000000..843d8d4dedb
--- /dev/null
+++ b/third_party/protozero/test/README.md
@@ -0,0 +1,52 @@
+
+# Tests
+
+Tests are using the [Catch Unit Test Framework](https://github.com/philsquared/Catch).
+
+## Organization of the unit tests
+
+Unit tests test low-level functions of the library. They are in the `unit`
+directory.
+
+
+## Organization of the reader/writer test cases
+
+The hart of the tests are the reader/writer tests checking all aspects of
+decoding and encoding protobuf files.
+
+Each test case is in its own directory under the `t` directory. Each directory
+contains (some of) the following files:
+
+* `reader_test_cases.cpp`: The C++ source code that runs the reader tests.
+* `writer_test_cases.cpp`: The C++ source code that runs the writer tests.
+* `data-*.pbf`: PBF data files used by the tests.
+* `testcase.proto`: Protobuf file describing the format of the data files.
+* `testcase.cpp`: C++ file for creating the data files.
+
+### Reader tests
+
+The CMake config finds all the `reader_test_cases.cpp` files and compiles them.
+Together with the `reader_tests.cpp` file they make up the `reader_tests`
+executable which can be called to execute all the reader tests.
+
+### Extra writer tests
+
+The CMake config finds all the `writer_test_cases.cpp` files and compiles them.
+Together with the `writer_tests.cpp` file they make up the `writer_tests`
+executable which can be called to execute all the writer tests.
+
+The writer tests need the Google protobuf library to work.
+
+
+## Creating test data from scratch
+
+Most tests use test data stored in PBF format in their directory. The files
+have the suffix `.pbf`. Most of those files have been generated from the
+provided `testcase.proto` and `testcase.cpp` files.
+
+Usually you do not have to do this, but if you want to re-generate the PBF
+data files, you can do so:
+
+    cd test
+    ./create_pbf_test_data.sh
+
diff --git a/third_party/libosmium/test/include/catch.hpp b/third_party/protozero/test/catch/catch.hpp
similarity index 98%
rename from third_party/libosmium/test/include/catch.hpp
rename to third_party/protozero/test/catch/catch.hpp
index 7c351e93181..6b5129d60f9 100644
--- a/third_party/libosmium/test/include/catch.hpp
+++ b/third_party/protozero/test/catch/catch.hpp
@@ -1,6 +1,6 @@
 /*
- *  Catch v1.9.7
- *  Generated: 2017-08-10 23:49:15.233907
+ *  Catch v1.12.0
+ *  Generated: 2018-01-11 21:56:34.893972
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
  *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -228,7 +228,12 @@
     ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
     ( defined __clang__ && __clang_major__ >= 3 )
 
-#define CATCH_INTERNAL_CONFIG_COUNTER
+// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former,
+// because __COUNTER__ is not properly handled by it.
+// This does not affect compilation
+#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
 
 #endif
 
@@ -309,10 +314,7 @@
 #if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
 #   define CATCH_CONFIG_CPP11_UNIQUE_PTR
 #endif
-// Use of __COUNTER__ is suppressed if __JETBRAINS_IDE__ is #defined (meaning we're being parsed by a JetBrains IDE for
-// analytics) because, at time of writing, __COUNTER__ is not properly handled by it.
-// This does not affect compilation
-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) && !defined(__JETBRAINS_IDE__)
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
 #   define CATCH_CONFIG_COUNTER
 #endif
 #if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)
@@ -1291,6 +1293,7 @@ namespace Catch {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
 #pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
 #endif
 
@@ -2166,6 +2169,12 @@ namespace Catch {
     };
 }
 
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+# define CATCH_INTERNAL_STRINGIFY(expr) #expr
+#else
+# define CATCH_INTERNAL_STRINGIFY(expr) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
 #if defined(CATCH_CONFIG_FAST_COMPILE)
 ///////////////////////////////////////////////////////////////////////////////
 // We can speedup compilation significantly by breaking into debugger lower in
@@ -2181,7 +2190,7 @@ namespace Catch {
 // the exception before it propagates back up to the runner.
 #define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
         __catchResult.setExceptionGuard(); \
         CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         ( __catchResult <= expr ).endExpression(); \
@@ -2193,9 +2202,9 @@ namespace Catch {
 
 #define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         __catchResult.setExceptionGuard(); \
-        __catchResult.captureMatch( arg, matcher, #matcher ); \
+        __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
         __catchResult.unsetExceptionGuard(); \
         INTERNAL_CATCH_REACT( __catchResult ) \
     } while( Catch::alwaysFalse() )
@@ -2214,7 +2223,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
         try { \
             CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
             ( __catchResult <= expr ).endExpression(); \
@@ -2240,7 +2249,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
         try { \
             static_cast<void>(expr); \
             __catchResult.captureResult( Catch::ResultWas::Ok ); \
@@ -2254,7 +2263,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition, #matcher ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition, CATCH_INTERNAL_STRINGIFY(matcher) ); \
         if( __catchResult.allowThrows() ) \
             try { \
                 static_cast<void>(expr); \
@@ -2271,7 +2280,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr ", " #exceptionType, resultDisposition ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
         if( __catchResult.allowThrows() ) \
             try { \
                 static_cast<void>(expr); \
@@ -2314,9 +2323,9 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         try { \
-            __catchResult.captureMatch( arg, matcher, #matcher ); \
+            __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
         } catch( ... ) { \
             __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
         } \
@@ -2822,7 +2831,8 @@ namespace Detail {
             if (relativeOK) {
                 return true;
             }
-            return std::fabs(lhs_v - rhs.m_value) < rhs.m_margin;
+
+            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
@@ -2894,7 +2904,7 @@ namespace Detail {
             if (relativeOK) {
                 return true;
             }
-            return std::fabs(lhs - rhs.m_value) < rhs.m_margin;
+            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
         }
 
         friend bool operator == ( Approx const& lhs, double rhs ) {
@@ -3852,6 +3862,12 @@ namespace Catch {
         Yes,
         No
     }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
 
     class TestSpec;
 
@@ -3965,13 +3981,15 @@ namespace Catch {
             showHelp( false ),
             showInvisibles( false ),
             filenamesAsTags( false ),
+            libIdentify( false ),
             abortAfter( -1 ),
             rngSeed( 0 ),
             verbosity( Verbosity::Normal ),
             warnings( WarnAbout::Nothing ),
             showDurations( ShowDurations::DefaultForReporter ),
             runOrder( RunTests::InDeclarationOrder ),
-            useColour( UseColour::Auto )
+            useColour( UseColour::Auto ),
+            waitForKeypress( WaitForKeypress::Never )
         {}
 
         bool listTests;
@@ -3986,6 +4004,7 @@ namespace Catch {
         bool showHelp;
         bool showInvisibles;
         bool filenamesAsTags;
+        bool libIdentify;
 
         int abortAfter;
         unsigned int rngSeed;
@@ -3995,6 +4014,7 @@ namespace Catch {
         ShowDurations::OrNot showDurations;
         RunTests::InWhatOrder runOrder;
         UseColour::YesOrNo useColour;
+        WaitForKeypress::When waitForKeypress;
 
         std::string outputFilename;
         std::string name;
@@ -5188,6 +5208,18 @@ namespace Catch {
         else
             throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
     }
+    inline void setWaitForKeypress( ConfigData& config, std::string const& keypress ) {
+        std::string keypressLc = toLower( keypress );
+        if( keypressLc == "start" )
+            config.waitForKeypress = WaitForKeypress::BeforeStart;
+        else if( keypressLc == "exit" )
+            config.waitForKeypress = WaitForKeypress::BeforeExit;
+        else if( keypressLc == "both" )
+            config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+        else
+            throw std::runtime_error( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
+    };
+
     inline void forceColour( ConfigData& config ) {
         config.useColour = UseColour::Yes;
     }
@@ -5323,6 +5355,14 @@ namespace Catch {
             .describe( "should output be colourised" )
             .bind( &setUseColour, "yes|no" );
 
+        cli["--libidentify"]
+            .describe( "report name and version according to libidentify standard" )
+            .bind( &ConfigData::libIdentify );
+
+        cli["--wait-for-keypress"]
+                .describe( "waits for a keypress before exiting" )
+                .bind( &setWaitForKeypress, "start|exit|both" );
+
         return cli;
     }
 
@@ -6700,7 +6740,10 @@ namespace Catch {
                 m_totals.assertions.passed++;
             }
             else if( !result.isOk() ) {
-                m_totals.assertions.failed++;
+                if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                    m_totals.assertions.failedButOk++;
+                else
+                    m_totals.assertions.failed++;
             }
 
             // We have no use for the return value (whether messages should be cleared), because messages were made scoped
@@ -6889,12 +6932,6 @@ namespace Catch {
             Counts assertions = m_totals.assertions - prevAssertions;
             bool missingAssertions = testForMissingAssertions( assertions );
 
-            if( testCaseInfo.okToFail() ) {
-                std::swap( assertions.failedButOk, assertions.failed );
-                m_totals.assertions.failed -= assertions.failedButOk;
-                m_totals.assertions.failedButOk += assertions.failedButOk;
-            }
-
             SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
             m_reporter->sectionEnded( testCaseSectionStats );
         }
@@ -7101,6 +7138,13 @@ namespace Catch {
             m_cli.usage( Catch::cout(), processName );
             Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
         }
+        void libIdentify() {
+            Catch::cout()
+                    << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
+                    << std::left << std::setw(16) << "category: " << "testframework\n"
+                    << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                    << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+        }
 
         int applyCommandLine( int argc, char const* const* const argv, OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
             try {
@@ -7108,6 +7152,8 @@ namespace Catch {
                 m_unusedTokens = m_cli.parseInto( Clara::argsToVector( argc, argv ), m_configData );
                 if( m_configData.showHelp )
                     showHelp( m_configData.processName );
+                if( m_configData.libIdentify )
+                    libIdentify();
                 m_config.reset();
             }
             catch( std::exception& ex ) {
@@ -7164,7 +7210,36 @@ namespace Catch {
     #endif
 
         int run() {
-            if( m_configData.showHelp )
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            int exitCode = runInternal();
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            return exitCode;
+        }
+
+        Clara::CommandLine<ConfigData> const& cli() const {
+            return m_cli;
+        }
+        std::vector<Clara::Parser::Token> const& unusedTokens() const {
+            return m_unusedTokens;
+        }
+        ConfigData& configData() {
+            return m_configData;
+        }
+        Config& config() {
+            if( !m_config )
+                m_config = new Config( m_configData );
+            return *m_config;
+        }
+    private:
+
+        int runInternal() {
+            if( m_configData.showHelp || m_configData.libIdentify )
                 return 0;
 
             try
@@ -7188,21 +7263,6 @@ namespace Catch {
             }
         }
 
-        Clara::CommandLine<ConfigData> const& cli() const {
-            return m_cli;
-        }
-        std::vector<Clara::Parser::Token> const& unusedTokens() const {
-            return m_unusedTokens;
-        }
-        ConfigData& configData() {
-            return m_configData;
-        }
-        Config& config() {
-            if( !m_config )
-                m_config = new Config( m_configData );
-            return *m_config;
-        }
-    private:
         Clara::CommandLine<ConfigData> m_cli;
         std::vector<Clara::Parser::Token> m_unusedTokens;
         ConfigData m_configData;
@@ -7227,7 +7287,7 @@ namespace Catch {
 namespace Catch {
 
     struct RandomNumberGenerator {
-        typedef std::ptrdiff_t result_type;
+        typedef unsigned int result_type;
 
         result_type operator()( result_type n ) const { return std::rand() % n; }
 
@@ -8148,7 +8208,7 @@ namespace Catch {
 
     std::string AssertionResult::getExpression() const {
         if( isFalseTest( m_info.resultDisposition ) )
-            return '!' + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
         else
             return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
     }
@@ -8406,7 +8466,7 @@ namespace Catch {
     }
 
     inline Version libraryVersion() {
-        static Version version( 1, 9, 7, "", 0 );
+        static Version version( 1, 12, 0, "", 0 );
         return version;
     }
 
@@ -10220,12 +10280,12 @@ namespace Catch {
 
             bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
 
-            if( includeResults ) {
+            if( includeResults || result.getResultType() == ResultWas::Warning ) {
                 // Print any info messages in <Info> tags.
                 for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
                      it != itEnd;
                      ++it ) {
-                    if( it->type == ResultWas::Info ) {
+                    if( it->type == ResultWas::Info && includeResults ) {
                         m_xml.scopedElement( "Info" )
                                 .writeText( it->message );
                     } else if ( it->type == ResultWas::Warning ) {
diff --git a/third_party/protozero/test/create_pbf_test_data.sh b/third_party/protozero/test/create_pbf_test_data.sh
new file mode 100755
index 00000000000..d4656232c35
--- /dev/null
+++ b/third_party/protozero/test/create_pbf_test_data.sh
@@ -0,0 +1,28 @@
+#!/bin/sh
+#
+#  create_pbf_test_data.sh [TESTCASE]
+#
+#  This script creates the test data for the given test case in protobuf format
+#  using the testcase.proto description and the testcase.cpp code.
+#
+#  If called without a test case it will iterate over all test cases generating
+#  all data.
+#
+
+set -e
+
+if [ -z "$1" ]; then
+    for dir in t/*; do
+        $0 $dir
+    done
+fi
+
+echo "Generating $1..."
+cd $1
+if [ -f testcase.proto ]; then
+    protoc --cpp_out=. testcase.proto
+    $CXX -std=c++11 -I../../include -o testcase testcase.cpp testcase.pb.cc -lprotobuf-lite -pthread
+    ./testcase
+fi
+cd ../..
+
diff --git a/third_party/protozero/test/include/packed_access.hpp b/third_party/protozero/test/include/packed_access.hpp
new file mode 100644
index 00000000000..1e9edb2a648
--- /dev/null
+++ b/third_party/protozero/test/include/packed_access.hpp
@@ -0,0 +1,296 @@
+// NOLINT(llvm-header-guard)
+
+#define PBF_TYPE_NAME PROTOZERO_TEST_STRING(PBF_TYPE)
+#define GET_TYPE PROTOZERO_TEST_CONCAT(get_packed_, PBF_TYPE)
+#define ADD_TYPE PROTOZERO_TEST_CONCAT(add_packed_, PBF_TYPE)
+
+using packed_field_type = PROTOZERO_TEST_CONCAT(protozero::packed_field_, PBF_TYPE);
+
+TEST_CASE("read repeated packed field: " PBF_TYPE_NAME) {
+    // Run these tests twice, the second time we basically move the data
+    // one byte down in the buffer. It doesn't matter how the data or buffer
+    // is aligned before that, in at least one of these cases the ints will
+    // not be aligned properly. So we test that even in that case the ints
+    // will be extracted properly.
+
+    for (std::string::size_type n = 0; n < 2; ++n) {
+        std::string abuffer;
+        abuffer.reserve(1000);
+        abuffer.append(n, '\0');
+
+        SECTION("empty") {
+            abuffer.append(load_data("repeated_packed_" PBF_TYPE_NAME "/data-empty"));
+
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("one") {
+            abuffer.append(load_data("repeated_packed_" PBF_TYPE_NAME "/data-one"));
+
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            const auto it_range = item.GET_TYPE();
+            REQUIRE_FALSE(item.next());
+
+            REQUIRE(it_range.begin() != it_range.end());
+            REQUIRE(*it_range.begin() == 17);
+            REQUIRE(std::next(it_range.begin()) == it_range.end());
+        }
+
+        SECTION("many") {
+            abuffer.append(load_data("repeated_packed_" PBF_TYPE_NAME "/data-many"));
+
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            const auto it_range = item.GET_TYPE();
+            REQUIRE_FALSE(item.next());
+
+            auto it = it_range.begin();
+            REQUIRE(it != it_range.end());
+            REQUIRE(*it++ ==   17);
+            REQUIRE(*it++ ==  200);
+            REQUIRE(*it++ ==    0);
+            REQUIRE(*it++ ==    1);
+            REQUIRE(*it++ == std::numeric_limits<cpp_type>::max());
+#if PBF_TYPE_IS_SIGNED
+            REQUIRE(*it++ == -200);
+            REQUIRE(*it++ ==   -1);
+            REQUIRE(*it++ == std::numeric_limits<cpp_type>::min());
+#endif
+            REQUIRE(it == it_range.end());
+        }
+
+        SECTION("swap iterator range") {
+            abuffer.append(load_data("repeated_packed_" PBF_TYPE_NAME "/data-many"));
+
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            auto it_range1 = item.GET_TYPE();
+            REQUIRE_FALSE(item.next());
+
+            decltype(it_range1) it_range;
+            using std::swap;
+            swap(it_range, it_range1);
+
+            auto it = it_range.begin();
+            REQUIRE(it != it_range.end());
+            REQUIRE(*it++ ==   17);
+            REQUIRE(*it++ ==  200);
+            REQUIRE(*it++ ==    0);
+            REQUIRE(*it++ ==    1);
+            REQUIRE(*it++ == std::numeric_limits<cpp_type>::max());
+        }
+
+        SECTION("end_of_buffer") {
+            abuffer.append(load_data("repeated_packed_" PBF_TYPE_NAME "/data-many"));
+
+            for (std::string::size_type i = 1; i < abuffer.size() - n; ++i) {
+                protozero::pbf_reader item{abuffer.data() + n, i};
+                REQUIRE(item.next());
+                REQUIRE_THROWS_AS(item.GET_TYPE(), const protozero::end_of_buffer_exception&);
+            }
+        }
+
+    }
+
+}
+
+TEST_CASE("write repeated packed field: " PBF_TYPE_NAME) {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty") {
+        cpp_type data[] = { 17 };
+        pw.ADD_TYPE(1, std::begin(data), std::begin(data) /* !!!! */);
+
+        REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-empty"));
+    }
+
+    SECTION("one") {
+        cpp_type data[] = { 17 };
+        pw.ADD_TYPE(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-one"));
+    }
+
+    SECTION("many") {
+        cpp_type data[] = {
+               17
+            , 200
+            ,   0
+            ,   1
+            ,std::numeric_limits<cpp_type>::max()
+#if PBF_TYPE_IS_SIGNED
+            ,-200
+            ,  -1
+            ,std::numeric_limits<cpp_type>::min()
+#endif
+        };
+        pw.ADD_TYPE(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-many"));
+    }
+
+}
+
+TEST_CASE("write repeated packed field using packed field: " PBF_TYPE_NAME) {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty - should do rollback") {
+        {
+            packed_field_type field{pw, 1};
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-empty"));
+    }
+
+    SECTION("one") {
+        {
+            packed_field_type field{pw, 1};
+            field.add_element(cpp_type(17));
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-one"));
+    }
+
+    SECTION("many") {
+        {
+            packed_field_type field{pw, 1};
+            field.add_element(cpp_type(  17));
+            field.add_element(cpp_type( 200));
+            field.add_element(cpp_type(   0));
+            field.add_element(cpp_type(   1));
+            field.add_element(std::numeric_limits<cpp_type>::max());
+#if PBF_TYPE_IS_SIGNED
+            field.add_element(cpp_type(-200));
+            field.add_element(cpp_type(  -1));
+            field.add_element(std::numeric_limits<cpp_type>::min());
+#endif
+            REQUIRE(field.valid());
+            SECTION("with commit") {
+                field.commit();
+                REQUIRE_FALSE(field.valid());
+            }
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-many"));
+    }
+}
+
+TEST_CASE("move repeated packed field: " PBF_TYPE_NAME) {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("move rvalue") {
+        packed_field_type field;
+        REQUIRE_FALSE(field.valid());
+        field = packed_field_type{pw, 1};
+        REQUIRE(field.valid());
+        field.add_element(cpp_type(17));
+    }
+
+    SECTION("explicit move") {
+        packed_field_type field2{pw, 1};
+        packed_field_type field;
+
+        REQUIRE(field2.valid());
+        REQUIRE_FALSE(field.valid());
+
+        field = std::move(field2);
+
+        REQUIRE_FALSE(field2.valid()); // NOLINT(hicpp-invalid-access-moved, bugprone-use-after-move)
+        REQUIRE(field.valid());
+
+        field.add_element(cpp_type(17));
+    }
+
+    SECTION("move constructor") {
+        packed_field_type field2{pw, 1};
+        REQUIRE(field2.valid());
+
+        packed_field_type field{std::move(field2)};
+        REQUIRE(field.valid());
+        REQUIRE_FALSE(field2.valid()); // NOLINT(hicpp-invalid-access-moved, bugprone-use-after-move)
+
+        field.add_element(cpp_type(17));
+    }
+
+    SECTION("swap") {
+        packed_field_type field;
+        packed_field_type field2{pw, 1};
+
+        REQUIRE_FALSE(field.valid());
+        REQUIRE(field2.valid());
+
+        using std::swap;
+        swap(field, field2);
+
+        REQUIRE(field.valid());
+        REQUIRE_FALSE(field2.valid());
+
+        field.add_element(cpp_type(17));
+    }
+
+    REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-one"));
+}
+
+TEST_CASE("write from different types of iterators: " PBF_TYPE_NAME) {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("from uint16_t") {
+#if PBF_TYPE_IS_SIGNED
+        const  int16_t data[] = { 1, 4, 9, 16, 25 };
+#else
+        const uint16_t data[] = { 1, 4, 9, 16, 25 };
+#endif
+
+        pw.ADD_TYPE(1, std::begin(data), std::end(data));
+    }
+
+    SECTION("from string") {
+        std::string data{"1 4 9 16 25"};
+        std::stringstream sdata{data};
+
+#if PBF_TYPE_IS_SIGNED
+        using test_type =  int32_t;
+#else
+        using test_type = uint32_t;
+#endif
+
+        std::istream_iterator<test_type> eod;
+        std::istream_iterator<test_type> it(sdata);
+
+        pw.ADD_TYPE(1, it, eod);
+    }
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    auto it_range = item.GET_TYPE();
+    REQUIRE_FALSE(item.next());
+    REQUIRE_FALSE(it_range.empty());
+    REQUIRE(std::distance(it_range.begin(), it_range.end()) == 5);
+    REQUIRE(it_range.size() == 5);
+
+    REQUIRE(it_range.front() ==  1); it_range.drop_front();
+    REQUIRE(it_range.front() ==  4); it_range.drop_front();
+    REQUIRE(std::distance(it_range.begin(), it_range.end()) == 3);
+    REQUIRE(it_range.size() == 3);
+    REQUIRE(it_range.front() ==  9); it_range.drop_front();
+    REQUIRE(it_range.front() == 16); it_range.drop_front();
+    REQUIRE(it_range.front() == 25); it_range.drop_front();
+    REQUIRE(it_range.empty());
+    REQUIRE(std::distance(it_range.begin(), it_range.end()) == 0);
+    REQUIRE(it_range.size() == 0); // NOLINT(readability-container-size-empty)
+
+    REQUIRE_THROWS_AS(it_range.front(), const assert_error&);
+    REQUIRE_THROWS_AS(it_range.drop_front(), const assert_error&);
+}
+
diff --git a/third_party/protozero/test/include/scalar_access.hpp b/third_party/protozero/test/include/scalar_access.hpp
new file mode 100644
index 00000000000..4f49184aabd
--- /dev/null
+++ b/third_party/protozero/test/include/scalar_access.hpp
@@ -0,0 +1,129 @@
+// NOLINT(llvm-header-guard)
+
+#define PBF_TYPE_NAME PROTOZERO_TEST_STRING(PBF_TYPE)
+#define GET_TYPE PROTOZERO_TEST_CONCAT(get_, PBF_TYPE)
+#define ADD_TYPE PROTOZERO_TEST_CONCAT(add_, PBF_TYPE)
+
+TEST_CASE("read field: " PBF_TYPE_NAME) {
+
+    SECTION("zero") {
+        const std::string buffer = load_data(PBF_TYPE_NAME "/data-zero");
+
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE(item.next());
+        REQUIRE(item.GET_TYPE() == 0);
+        REQUIRE_FALSE(item.next());
+    }
+
+    SECTION("positive") {
+        const std::string buffer = load_data(PBF_TYPE_NAME "/data-pos");
+
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE(item.next());
+        REQUIRE(item.GET_TYPE() == 1);
+        REQUIRE_FALSE(item.next());
+    }
+
+    SECTION("pos200") {
+        const std::string buffer = load_data(PBF_TYPE_NAME "/data-pos200");
+
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE(item.next());
+        REQUIRE(item.GET_TYPE() == 200);
+        REQUIRE_FALSE(item.next());
+    }
+
+    SECTION("max") {
+        const std::string buffer = load_data(PBF_TYPE_NAME "/data-max");
+
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE(item.next());
+        REQUIRE(item.GET_TYPE() == std::numeric_limits<cpp_type>::max());
+        REQUIRE_FALSE(item.next());
+    }
+
+#if PBF_TYPE_IS_SIGNED
+    SECTION("negative") {
+        if (std::is_signed<cpp_type>::value) {
+            const std::string buffer = load_data(PBF_TYPE_NAME "/data-neg");
+
+            protozero::pbf_reader item{buffer};
+
+            REQUIRE(item.next());
+            REQUIRE(item.GET_TYPE() == -1);
+            REQUIRE_FALSE(item.next());
+        }
+    }
+
+    SECTION("neg200") {
+        const std::string buffer = load_data(PBF_TYPE_NAME "/data-neg200");
+
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE(item.next());
+        REQUIRE(item.GET_TYPE() == -200);
+        REQUIRE_FALSE(item.next());
+    }
+
+    SECTION("min") {
+        if (std::is_signed<cpp_type>::value) {
+            const std::string buffer = load_data(PBF_TYPE_NAME "/data-min");
+
+            protozero::pbf_reader item{buffer};
+
+            REQUIRE(item.next());
+            REQUIRE(item.GET_TYPE() == std::numeric_limits<cpp_type>::min());
+            REQUIRE_FALSE(item.next());
+        }
+    }
+#endif
+
+    SECTION("end_of_buffer") {
+        const std::string buffer = load_data(PBF_TYPE_NAME "/data-max");
+
+        for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+            protozero::pbf_reader item{buffer.data(), i};
+            REQUIRE(item.next());
+            REQUIRE_THROWS_AS(item.GET_TYPE(), const protozero::end_of_buffer_exception&);
+        }
+    }
+}
+
+TEST_CASE("write field: " PBF_TYPE_NAME) {
+    std::string buffer;
+    protozero::pbf_writer pw(buffer);
+
+    SECTION("zero") {
+        pw.ADD_TYPE(1, 0);
+        REQUIRE(buffer == load_data(PBF_TYPE_NAME "/data-zero"));
+    }
+
+    SECTION("positive") {
+        pw.ADD_TYPE(1, 1);
+        REQUIRE(buffer == load_data(PBF_TYPE_NAME "/data-pos"));
+    }
+
+    SECTION("max") {
+        pw.ADD_TYPE(1, std::numeric_limits<cpp_type>::max());
+        REQUIRE(buffer == load_data(PBF_TYPE_NAME "/data-max"));
+    }
+
+#if PBF_TYPE_IS_SIGNED
+    SECTION("negative") {
+        pw.ADD_TYPE(1, -1);
+        REQUIRE(buffer == load_data(PBF_TYPE_NAME "/data-neg"));
+    }
+
+    SECTION("min") {
+        if (std::is_signed<cpp_type>::value) {
+            pw.ADD_TYPE(1, std::numeric_limits<cpp_type>::min());
+            REQUIRE(buffer == load_data(PBF_TYPE_NAME "/data-min"));
+        }
+    }
+#endif
+}
+
diff --git a/third_party/protozero/test/include/test.hpp b/third_party/protozero/test/include/test.hpp
new file mode 100644
index 00000000000..75425796025
--- /dev/null
+++ b/third_party/protozero/test/include/test.hpp
@@ -0,0 +1,28 @@
+#ifndef TEST_HPP
+#define TEST_HPP
+
+#include <catch.hpp>
+
+#include <stdexcept>
+// Define protozero_assert() to throw this error. This allows the tests to
+// check that the assert fails.
+struct assert_error : public std::runtime_error {
+    explicit assert_error(const char* what_arg) : std::runtime_error(what_arg) {
+    }
+};
+#define protozero_assert(x) if (!(x)) { throw assert_error{#x}; }
+
+#include <protozero/pbf_builder.hpp>
+#include <protozero/pbf_message.hpp>
+#include <protozero/pbf_reader.hpp>
+#include <protozero/pbf_writer.hpp>
+
+extern std::string load_data(const std::string& filename);
+
+#define PROTOZERO_TEST_CONCAT2(x, y) x##y
+#define PROTOZERO_TEST_CONCAT(x, y) PROTOZERO_TEST_CONCAT2(x, y)
+
+#define PROTOZERO_TEST_STRING2(s) #s
+#define PROTOZERO_TEST_STRING(s) PROTOZERO_TEST_STRING2(s)
+
+#endif // TEST_HPP
diff --git a/third_party/protozero/test/include/testcase.hpp b/third_party/protozero/test/include/testcase.hpp
new file mode 100644
index 00000000000..c59afca2940
--- /dev/null
+++ b/third_party/protozero/test/include/testcase.hpp
@@ -0,0 +1,21 @@
+#ifndef TESTCASE_HPP
+#define TESTCASE_HPP
+
+#include <cassert>
+#include <fstream>
+#include <limits>
+#include <string>
+
+template <class T>
+std::string write_to_file(const T& msg, const char* filename) {
+    std::string out;
+
+    msg.SerializeToString(&out);
+    std::ofstream d{filename, std::ios_base::out|std::ios_base::binary};
+    assert(d.is_open());
+    d << out;
+
+    return out;
+}
+
+#endif // TESTCASE_HPP
diff --git a/third_party/protozero/test/reader_tests.cpp b/third_party/protozero/test/reader_tests.cpp
new file mode 100644
index 00000000000..ed0f13944a4
--- /dev/null
+++ b/third_party/protozero/test/reader_tests.cpp
@@ -0,0 +1,30 @@
+
+#include <fstream>
+#include <stdexcept>
+#include <string>
+
+#define CATCH_CONFIG_MAIN
+#include <test.hpp> // IWYU pragma: keep
+
+std::string load_data(const std::string& filename) {
+    const char* tests_dir = std::getenv("TESTS_DIR");
+    if (tests_dir == nullptr) {
+        tests_dir = "test";
+    }
+
+    std::string fullname{tests_dir};
+    fullname += "/t/";
+    fullname += filename;
+    fullname += ".pbf";
+
+    std::ifstream stream{fullname, std::ios_base::in | std::ios_base::binary};
+    if (!stream.is_open()) {
+        throw std::runtime_error{"could not open: '" + filename + "'"};
+    }
+    std::string buffer{std::istreambuf_iterator<char>(stream.rdbuf()),
+                       std::istreambuf_iterator<char>()};
+    stream.close();
+
+    return buffer;
+}
+
diff --git a/third_party/protozero/test/t/alignment/reader_test_cases.cpp b/third_party/protozero/test/t/alignment/reader_test_cases.cpp
new file mode 100644
index 00000000000..d7f995fb0ae
--- /dev/null
+++ b/third_party/protozero/test/t/alignment/reader_test_cases.cpp
@@ -0,0 +1,122 @@
+
+#include <test.hpp>
+
+// Run these tests twice, the second time we basically move the data
+// one byte down in the buffer. It doesn't matter how the data or buffer
+// is aligned before that, in at least one of these cases the int32 will
+// not be aligned properly. So we test that even in that case the int32
+// will be extracted properly.
+
+TEST_CASE("check alignment issues for fixed32 field") {
+    for (std::string::size_type n = 0; n < 2; ++n) {
+
+        std::string abuffer;
+        abuffer.reserve(1000);
+        abuffer.append(n, '\0');
+
+        SECTION("zero") {
+            abuffer.append(load_data("fixed32/data-zero"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_fixed32() == 0UL);
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("positive") {
+            abuffer.append(load_data("fixed32/data-pos"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_fixed32() == 1UL);
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("max") {
+            abuffer.append(load_data("fixed32/data-max"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_fixed32() == std::numeric_limits<uint32_t>::max());
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("end_of_buffer") {
+            abuffer.append(load_data("fixed32/data-pos"));
+
+            for (std::string::size_type i = 1; i < abuffer.size() - n; ++i) {
+                protozero::pbf_reader item{abuffer.data() + n, i};
+                REQUIRE(item.next());
+                REQUIRE_THROWS_AS(item.get_fixed32(), const protozero::end_of_buffer_exception&);
+            }
+        }
+
+        SECTION("assert detecting tag==0") {
+            abuffer.append(load_data("fixed32/data-zero"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE_THROWS_AS(item.get_fixed32(), const assert_error&);
+            REQUIRE(item.next());
+            REQUIRE(item.get_fixed32() == 0UL);
+            REQUIRE_THROWS(item.get_fixed32());
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("skip") {
+            abuffer.append(load_data("fixed32/data-zero"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE_THROWS_AS(item.skip(), const assert_error&);
+            REQUIRE(item.next());
+            item.skip();
+            REQUIRE_THROWS(item.skip());
+            REQUIRE_FALSE(item.next());
+        }
+    }
+}
+
+TEST_CASE("check alignment issues for fixed64 field") {
+    for (std::string::size_type n = 0; n < 2; ++n) {
+        std::string abuffer;
+        abuffer.reserve(1000);
+        abuffer.append(n, '\0');
+
+        SECTION("zero") {
+            abuffer.append(load_data("fixed64/data-zero"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_fixed64() == 0ULL);
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("positive") {
+            abuffer.append(load_data("fixed64/data-pos"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_fixed64() == 1ULL);
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("max") {
+            abuffer.append(load_data("fixed64/data-max"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_fixed64() == std::numeric_limits<uint64_t>::max());
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("end_of_buffer") {
+            abuffer.append(load_data("fixed64/data-pos"));
+
+            for (std::string::size_type i = 1; i < abuffer.size() - n; ++i) {
+                protozero::pbf_reader item{abuffer.data() + n, i};
+                REQUIRE(item.next());
+                REQUIRE_THROWS_AS(item.get_fixed64(), const protozero::end_of_buffer_exception&);
+            }
+        }
+    }
+}
+
diff --git a/third_party/protozero/test/t/bool/bool_testcase.proto b/third_party/protozero/test/t/bool/bool_testcase.proto
new file mode 100644
index 00000000000..a341f38f9f5
--- /dev/null
+++ b/third_party/protozero/test/t/bool/bool_testcase.proto
@@ -0,0 +1,14 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestBoolean;
+
+message Test {
+
+    // this should be bool, but we are using uint32
+    // to be able to encode values other than 0 (false)
+    // and 1 (true)
+    required uint32 b = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/bool/data-also-true.pbf b/third_party/protozero/test/t/bool/data-also-true.pbf
new file mode 100644
index 00000000000..009a24fee40
--- /dev/null
+++ b/third_party/protozero/test/t/bool/data-also-true.pbf
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/third_party/protozero/test/t/bool/data-false.pbf b/third_party/protozero/test/t/bool/data-false.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/bool/data-false.pbf differ
diff --git a/third_party/protozero/test/t/bool/data-still-true.pbf b/third_party/protozero/test/t/bool/data-still-true.pbf
new file mode 100644
index 00000000000..27e77d6b230
--- /dev/null
+++ b/third_party/protozero/test/t/bool/data-still-true.pbf
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/third_party/protozero/test/t/bool/data-true.pbf b/third_party/protozero/test/t/bool/data-true.pbf
new file mode 100644
index 00000000000..e19a122a540
--- /dev/null
+++ b/third_party/protozero/test/t/bool/data-true.pbf
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/bool/reader_test_cases.cpp b/third_party/protozero/test/t/bool/reader_test_cases.cpp
new file mode 100644
index 00000000000..56d6364c1bf
--- /dev/null
+++ b/third_party/protozero/test/t/bool/reader_test_cases.cpp
@@ -0,0 +1,141 @@
+
+#include <test.hpp>
+
+namespace TestBoolean {
+
+enum class Test : protozero::pbf_tag_type {
+    required_bool_b = 1
+};
+
+} // end namespace TestBoolean
+
+TEST_CASE("read bool field using pbf_reader: false") {
+    const std::string buffer = load_data("bool/data-false");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE_FALSE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bool field using pbf_reader: true") {
+    const std::string buffer = load_data("bool/data-true");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bool field using pbf_reader: also true") {
+    const std::string buffer = load_data("bool/data-also-true");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next(1));
+    REQUIRE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bool field using pbf_reader: still true") {
+    const std::string buffer = load_data("bool/data-still-true");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next(1));
+    REQUIRE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bool field using pbf_message: false") {
+    const std::string buffer = load_data("bool/data-false");
+
+    protozero::pbf_message<TestBoolean::Test> item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE_FALSE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bool field using pbf_message: true") {
+    const std::string buffer = load_data("bool/data-true");
+
+    protozero::pbf_message<TestBoolean::Test> item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bool field using pbf_message: also true") {
+    const std::string buffer = load_data("bool/data-also-true");
+
+    protozero::pbf_message<TestBoolean::Test> item{buffer};
+
+    REQUIRE(item.next(TestBoolean::Test::required_bool_b));
+    REQUIRE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bool field using pbf_message: still true") {
+    const std::string buffer = load_data("bool/data-still-true");
+
+    protozero::pbf_message<TestBoolean::Test> item{buffer};
+
+    REQUIRE(item.next(TestBoolean::Test::required_bool_b));
+    REQUIRE(item.get_bool());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("write bool field using pbf_writer") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("false") {
+        pw.add_bool(1, false);
+        REQUIRE(buffer == load_data("bool/data-false"));
+    }
+
+    SECTION("true") {
+        pw.add_bool(1, true);
+        REQUIRE(buffer == load_data("bool/data-true"));
+    }
+}
+
+TEST_CASE("write bool field using pbf_builder") {
+    std::string buffer;
+    protozero::pbf_builder<TestBoolean::Test> pw{buffer};
+
+    SECTION("false") {
+        pw.add_bool(TestBoolean::Test::required_bool_b, false);
+        REQUIRE(buffer == load_data("bool/data-false"));
+    }
+
+    SECTION("true") {
+        pw.add_bool(TestBoolean::Test::required_bool_b, true);
+        REQUIRE(buffer == load_data("bool/data-true"));
+    }
+}
+
+TEST_CASE("write bool field using moved pbf_builder") {
+    std::string buffer;
+    protozero::pbf_builder<TestBoolean::Test> pw2{buffer};
+    REQUIRE(pw2.valid());
+
+    protozero::pbf_builder<TestBoolean::Test> pw{std::move(pw2)};
+    REQUIRE(pw.valid());
+    REQUIRE_FALSE(pw2.valid()); // NOLINT(hicpp-invalid-access-moved, bugprone-use-after-move)
+
+    SECTION("false") {
+        pw.add_bool(TestBoolean::Test::required_bool_b, false);
+        REQUIRE(buffer == load_data("bool/data-false"));
+    }
+
+    SECTION("true") {
+        pw.add_bool(TestBoolean::Test::required_bool_b, true);
+        REQUIRE(buffer == load_data("bool/data-true"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/bool/testcase.cpp b/third_party/protozero/test/t/bool/testcase.cpp
new file mode 100644
index 00000000000..b2a8f76b10b
--- /dev/null
+++ b/third_party/protozero/test/t/bool/testcase.cpp
@@ -0,0 +1,20 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestBoolean::Test msg;
+
+    msg.set_b(0);
+    write_to_file(msg, "data-false.pbf");
+
+    msg.set_b(1);
+    write_to_file(msg, "data-true.pbf");
+
+    msg.set_b(2);
+    write_to_file(msg, "data-also-true.pbf");
+
+    msg.set_b(2000);
+    write_to_file(msg, "data-still-true.pbf");
+}
+
diff --git a/third_party/protozero/test/t/bool/writer_test_cases.cpp b/third_party/protozero/test/t/bool/writer_test_cases.cpp
new file mode 100644
index 00000000000..89a5730d648
--- /dev/null
+++ b/third_party/protozero/test/t/bool/writer_test_cases.cpp
@@ -0,0 +1,32 @@
+
+#include <string>
+
+#include <test.hpp> // IWYU pragma: keep
+
+#include "t/bool/bool_testcase.pb.h"
+
+TEST_CASE("write bool field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestBoolean::Test msg;
+
+    SECTION("false") {
+        pw.add_bool(1, false);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE_FALSE(msg.b());
+    }
+
+    SECTION("true") {
+        pw.add_bool(1, true);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.b());
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/bytes/bytes_testcase.proto b/third_party/protozero/test/t/bytes/bytes_testcase.proto
new file mode 100644
index 00000000000..3c3019c4364
--- /dev/null
+++ b/third_party/protozero/test/t/bytes/bytes_testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestBytes;
+
+message Test {
+
+    required bytes s = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/bytes/data-binary.pbf b/third_party/protozero/test/t/bytes/data-binary.pbf
new file mode 100644
index 00000000000..f6aaef7852f
--- /dev/null
+++ b/third_party/protozero/test/t/bytes/data-binary.pbf
@@ -0,0 +1,2 @@
+
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/bytes/data-empty.pbf b/third_party/protozero/test/t/bytes/data-empty.pbf
new file mode 100644
index 00000000000..59f144ee093
Binary files /dev/null and b/third_party/protozero/test/t/bytes/data-empty.pbf differ
diff --git a/third_party/protozero/test/t/bytes/data-one.pbf b/third_party/protozero/test/t/bytes/data-one.pbf
new file mode 100644
index 00000000000..2764cf5cdac
--- /dev/null
+++ b/third_party/protozero/test/t/bytes/data-one.pbf
@@ -0,0 +1,2 @@
+
+
x
\ No newline at end of file
diff --git a/third_party/protozero/test/t/bytes/data-string.pbf b/third_party/protozero/test/t/bytes/data-string.pbf
new file mode 100644
index 00000000000..d7369a75954
--- /dev/null
+++ b/third_party/protozero/test/t/bytes/data-string.pbf
@@ -0,0 +1,2 @@
+
+foobar
\ No newline at end of file
diff --git a/third_party/protozero/test/t/bytes/reader_test_cases.cpp b/third_party/protozero/test/t/bytes/reader_test_cases.cpp
new file mode 100644
index 00000000000..a7a721b65ee
--- /dev/null
+++ b/third_party/protozero/test/t/bytes/reader_test_cases.cpp
@@ -0,0 +1,139 @@
+
+#include <test.hpp>
+
+TEST_CASE("read bytes field: empty") {
+    const std::string buffer = load_data("bytes/data-empty");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_bytes().empty());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bytes field: one") {
+    const std::string buffer = load_data("bytes/data-one");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_bytes() == "x");
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bytes field: string") {
+    const std::string buffer = load_data("bytes/data-string");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_bytes() == "foobar");
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bytes field: binary") {
+    const std::string buffer = load_data("bytes/data-binary");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    const std::string data = item.get_bytes();
+    REQUIRE(data.size() == 3);
+    REQUIRE(data[0] == char(1));
+    REQUIRE(data[1] == char(2));
+    REQUIRE(data[2] == char(3));
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read bytes field: end of buffer") {
+    const std::string buffer = load_data("bytes/data-binary");
+
+    for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+        protozero::pbf_reader item{buffer.data(), i};
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.get_bytes(), const protozero::end_of_buffer_exception&);
+    }
+}
+
+TEST_CASE("write bytes field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty") {
+        pw.add_string(1, "");
+        REQUIRE(buffer == load_data("bytes/data-empty"));
+    }
+
+    SECTION("one") {
+        pw.add_string(1, "x");
+        REQUIRE(buffer == load_data("bytes/data-one"));
+    }
+
+    SECTION("string") {
+        pw.add_string(1, "foobar");
+        REQUIRE(buffer == load_data("bytes/data-string"));
+    }
+
+    SECTION("binary") {
+        std::string data;
+        data.append(1, char(1));
+        data.append(1, char(2));
+        data.append(1, char(3));
+
+        pw.add_string(1, data);
+
+        REQUIRE(buffer == load_data("bytes/data-binary"));
+    }
+}
+
+TEST_CASE("write bytes field using vectored approach") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("using two strings") {
+        std::string d1{"foo"};
+        std::string d2{"bar"};
+
+        pw.add_bytes_vectored(1, d1, d2);
+    }
+
+    SECTION("using a string and a dataview") {
+        std::string d1{"foo"};
+        std::string d2{"bar"};
+        protozero::data_view dv{d2};
+
+        pw.add_bytes_vectored(1, d1, dv);
+    }
+
+    SECTION("using three strings") {
+        std::string d1{"foo"};
+        std::string d2{"ba"};
+        std::string d3{"r"};
+
+        pw.add_bytes_vectored(1, d1, d2, d3);
+    }
+
+    SECTION("with empty string") {
+        std::string d1{"foo"};
+        std::string d2{};
+        std::string d3{"bar"};
+
+        pw.add_bytes_vectored(1, d1, d2, d3);
+    }
+
+    REQUIRE(buffer == load_data("bytes/data-string"));
+}
+
+TEST_CASE("write bytes field using vectored approach with builder") {
+    enum class foo : protozero::pbf_tag_type { bar = 1 };
+    std::string buffer;
+    protozero::pbf_builder<foo> pw{buffer};
+
+    const std::string d1{"foo"};
+    const std::string d2{"bar"};
+
+    pw.add_bytes_vectored(foo::bar, d1, d2);
+
+    REQUIRE(buffer == load_data("bytes/data-string"));
+}
+
diff --git a/third_party/protozero/test/t/bytes/testcase.cpp b/third_party/protozero/test/t/bytes/testcase.cpp
new file mode 100644
index 00000000000..32e37b81274
--- /dev/null
+++ b/third_party/protozero/test/t/bytes/testcase.cpp
@@ -0,0 +1,24 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestBytes::Test msg;
+
+    msg.set_s("");
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.set_s("x");
+    write_to_file(msg, "data-one.pbf");
+
+    msg.set_s("foobar");
+    write_to_file(msg, "data-string.pbf");
+
+    std::string data;
+    data.append(1, char(1));
+    data.append(1, char(2));
+    data.append(1, char(3));
+    msg.set_s(data);
+    write_to_file(msg, "data-binary.pbf");
+}
+
diff --git a/third_party/protozero/test/t/bytes/writer_test_cases.cpp b/third_party/protozero/test/t/bytes/writer_test_cases.cpp
new file mode 100644
index 00000000000..af6ce450bb1
--- /dev/null
+++ b/third_party/protozero/test/t/bytes/writer_test_cases.cpp
@@ -0,0 +1,54 @@
+
+#include <test.hpp>
+
+#include "t/bytes/bytes_testcase.pb.h"
+
+TEST_CASE("write bytes field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestBytes::Test msg;
+
+    SECTION("empty") {
+        pw.add_string(1, "");
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.s().empty());
+    }
+
+    SECTION("one") {
+        pw.add_string(1, "x");
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.s() == "x");
+    }
+
+    SECTION("string") {
+        pw.add_string(1, "foobar");
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.s() == "foobar");
+    }
+
+    SECTION("binary") {
+        std::string data;
+        data.append(1, char(1));
+        data.append(1, char(2));
+        data.append(1, char(3));
+
+        pw.add_string(1, data);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.s().size() == 3);
+        REQUIRE(msg.s()[1] == char(2));
+        REQUIRE(msg.s()[2] == char(3));
+        REQUIRE(msg.s()[2] == char(3));
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/complex/data-all.pbf b/third_party/protozero/test/t/complex/data-all.pbf
new file mode 100644
index 00000000000..50cd4662f78
Binary files /dev/null and b/third_party/protozero/test/t/complex/data-all.pbf differ
diff --git a/third_party/protozero/test/t/complex/data-minimal.pbf b/third_party/protozero/test/t/complex/data-minimal.pbf
new file mode 100644
index 00000000000..cfea0f0124c
Binary files /dev/null and b/third_party/protozero/test/t/complex/data-minimal.pbf differ
diff --git a/third_party/protozero/test/t/complex/data-some.pbf b/third_party/protozero/test/t/complex/data-some.pbf
new file mode 100644
index 00000000000..d5093666e26
Binary files /dev/null and b/third_party/protozero/test/t/complex/data-some.pbf differ
diff --git a/third_party/protozero/test/t/complex/reader_test_cases.cpp b/third_party/protozero/test/t/complex/reader_test_cases.cpp
new file mode 100644
index 00000000000..5b722d80631
--- /dev/null
+++ b/third_party/protozero/test/t/complex/reader_test_cases.cpp
@@ -0,0 +1,686 @@
+
+#include <test.hpp>
+
+namespace TestComplex {
+
+enum class Test : protozero::pbf_tag_type {
+    required_fixed32_f      = 1,
+    optional_int64_i        = 2,
+    optional_int64_j        = 3,
+    required_Sub_submessage = 5,
+    optional_string_s       = 8,
+    repeated_uint32_u       = 4,
+    packed_sint32_d         = 7
+};
+
+enum class Sub : protozero::pbf_tag_type {
+    required_string_s = 1
+};
+
+} // namespace TestComplex
+
+TEST_CASE("read complex data using pbf_reader: minimal") {
+    const std::string buffer = load_data("complex/data-minimal");
+
+    protozero::pbf_reader item{buffer};
+
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("read complex data using pbf_reader: some") {
+    const std::string buffer = load_data("complex/data-some");
+
+    protozero::pbf_reader item2{buffer};
+    protozero::pbf_reader item;
+    using std::swap;
+    swap(item, item2);
+
+    uint32_t sum_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 2: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case 4: {
+                sum_of_u += item.get_uint32();
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(sum_of_u == 66);
+}
+
+TEST_CASE("read complex data using pbf_reader: all") {
+    const std::string buffer = load_data("complex/data-all");
+
+    protozero::pbf_reader item{buffer};
+
+    int number_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 2: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case 3: {
+                REQUIRE(item.get_int64() == 555555555LL);
+                break;
+            }
+            case 4: {
+                item.skip();
+                ++number_of_u;
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            case 7: {
+                const auto pi = item.get_packed_sint32();
+                int32_t sum = 0;
+                for (auto val : pi) {
+                    sum += val;
+                }
+                REQUIRE(sum == 5);
+                break;
+            }
+            case 8: {
+                REQUIRE(item.get_string() == "optionalstring");
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(number_of_u == 5);
+}
+
+TEST_CASE("read complex data using pbf_reader: skip everything") {
+    const std::string buffer = load_data("complex/data-all");
+
+    protozero::pbf_reader item{buffer};
+
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 7:
+            case 8:
+                item.skip();
+                break;
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("read complex data using pbf_message: minimal") {
+    const std::string buffer = load_data("complex/data-minimal");
+
+    protozero::pbf_message<TestComplex::Test> item{buffer};
+
+    while (item.next()) {
+        switch (item.tag()) {
+            case TestComplex::Test::required_fixed32_f: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case TestComplex::Test::required_Sub_submessage: {
+                protozero::pbf_message<TestComplex::Sub> subitem{item.get_message()};
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("read complex data using pbf_message: some") {
+    const std::string buffer = load_data("complex/data-some");
+
+    protozero::pbf_message<TestComplex::Test> item2{buffer};
+    protozero::pbf_message<TestComplex::Test> item;
+    using std::swap;
+    swap(item, item2);
+
+    uint32_t sum_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case TestComplex::Test::required_fixed32_f: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case TestComplex::Test::optional_int64_i: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case TestComplex::Test::repeated_uint32_u: {
+                sum_of_u += item.get_uint32();
+                break;
+            }
+            case TestComplex::Test::required_Sub_submessage: {
+                protozero::pbf_message<TestComplex::Sub> subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(sum_of_u == 66);
+}
+
+TEST_CASE("read complex data using pbf_message: all") {
+    const std::string buffer = load_data("complex/data-all");
+
+    protozero::pbf_message<TestComplex::Test> item{buffer};
+
+    int number_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case TestComplex::Test::required_fixed32_f: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case TestComplex::Test::optional_int64_i: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case TestComplex::Test::optional_int64_j: {
+                REQUIRE(item.get_int64() == 555555555LL);
+                break;
+            }
+            case TestComplex::Test::repeated_uint32_u: {
+                item.skip();
+                ++number_of_u;
+                break;
+            }
+            case TestComplex::Test::required_Sub_submessage: {
+                protozero::pbf_message<TestComplex::Sub> subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            case TestComplex::Test::packed_sint32_d: {
+                const auto pi = item.get_packed_sint32();
+                int32_t sum = 0;
+                for (auto val : pi) {
+                    sum += val;
+                }
+                REQUIRE(sum == 5);
+                break;
+            }
+            case TestComplex::Test::optional_string_s: {
+                REQUIRE(item.get_string() == "optionalstring");
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(number_of_u == 5);
+}
+
+TEST_CASE("read complex data using pbf_message: skip everything") {
+    const std::string buffer = load_data("complex/data-all");
+
+    protozero::pbf_message<TestComplex::Test> item{buffer};
+
+    while (item.next()) {
+        switch (item.tag()) {
+            case TestComplex::Test::required_fixed32_f:
+            case TestComplex::Test::optional_int64_i:
+            case TestComplex::Test::optional_int64_j:
+            case TestComplex::Test::repeated_uint32_u:
+            case TestComplex::Test::required_Sub_submessage:
+            case TestComplex::Test::packed_sint32_d:
+            case TestComplex::Test::optional_string_s:
+                item.skip();
+                break;
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("write complex data using pbf_writer: minimal") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+    pw.add_fixed32(1, 12345678);
+
+    std::string submessage;
+    protozero::pbf_writer pws{submessage};
+    pws.add_string(1, "foobar");
+
+    pw.add_message(5, submessage);
+
+    protozero::pbf_reader item{buffer};
+
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("write complex data using pbf_writer: some") {
+    std::string buffer;
+    protozero::pbf_writer pw2{buffer};
+    pw2.add_fixed32(1, 12345678);
+
+    protozero::pbf_writer pw;
+    using std::swap;
+    swap(pw, pw2);
+
+    REQUIRE(pw.valid());
+    REQUIRE_FALSE(pw2.valid());
+
+    std::string submessage;
+    protozero::pbf_writer pws{submessage};
+    pws.add_string(1, "foobar");
+
+    pw.add_uint32(4, 22);
+    pw.add_uint32(4, 44);
+    pw.add_int64(2, -9876543);
+    pw.add_message(5, submessage);
+
+    protozero::pbf_reader item{buffer};
+
+    uint32_t sum_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 2: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case 4: {
+                sum_of_u += item.get_uint32();
+                break;
+            }
+            case 5: {
+                const auto view = item.get_view();
+                protozero::pbf_reader subitem{view};
+                REQUIRE(subitem.next());
+                REQUIRE(std::string(subitem.get_view()) == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(sum_of_u == 66);
+}
+
+TEST_CASE("write complex data using pbf_writer: all") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+    pw.add_fixed32(1, 12345678);
+
+    std::string submessage;
+    protozero::pbf_writer pws{submessage};
+    pws.add_string(1, "foobar");
+    pw.add_message(5, submessage);
+
+    pw.add_uint32(4, 22);
+    pw.add_uint32(4, 44);
+    pw.add_int64(2, -9876543);
+    pw.add_uint32(4, 44);
+    pw.add_uint32(4, 66);
+    pw.add_uint32(4, 66);
+
+    const int32_t d[] = { -17, 22 };
+    pw.add_packed_sint32(7, std::begin(d), std::end(d));
+
+    pw.add_int64(3, 555555555);
+
+    protozero::pbf_reader item{buffer};
+
+    int number_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 2: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case 3: {
+                REQUIRE(item.get_int64() == 555555555LL);
+                break;
+            }
+            case 4: {
+                item.skip();
+                ++number_of_u;
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            case 7: {
+                const auto pi = item.get_packed_sint32();
+                int32_t sum = 0;
+                for (auto val : pi) {
+                    sum += val;
+                }
+                REQUIRE(sum == 5);
+                break;
+            }
+            case 8: {
+                REQUIRE(item.get_string() == "optionalstring");
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(number_of_u == 5);
+}
+
+TEST_CASE("write complex data using pbf_builder: minimal") {
+    std::string buffer;
+    protozero::pbf_builder<TestComplex::Test> pw{buffer};
+    pw.add_fixed32(TestComplex::Test::required_fixed32_f, 12345678);
+
+    std::string submessage;
+    protozero::pbf_builder<TestComplex::Sub> pws{submessage};
+    pws.add_string(TestComplex::Sub::required_string_s, "foobar");
+
+    pw.add_message(TestComplex::Test::required_Sub_submessage, submessage);
+
+    protozero::pbf_reader item{buffer};
+
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("write complex data using pbf_builder: some") {
+    std::string buffer;
+    protozero::pbf_builder<TestComplex::Test> pw2{buffer};
+    pw2.add_fixed32(TestComplex::Test::required_fixed32_f, 12345678);
+
+    std::string dummy_buffer;
+    protozero::pbf_builder<TestComplex::Test> pw{dummy_buffer};
+    using std::swap;
+    swap(pw, pw2);
+
+    std::string submessage;
+    protozero::pbf_builder<TestComplex::Sub> pws{submessage};
+    pws.add_string(TestComplex::Sub::required_string_s, "foobar");
+
+    pw.add_uint32(TestComplex::Test::repeated_uint32_u, 22);
+    pw.add_uint32(TestComplex::Test::repeated_uint32_u, 44);
+    pw.add_int64(TestComplex::Test::optional_int64_i, -9876543);
+    pw.add_message(TestComplex::Test::required_Sub_submessage, submessage);
+
+    protozero::pbf_reader item{buffer};
+
+    uint32_t sum_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 2: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case 4: {
+                sum_of_u += item.get_uint32();
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(sum_of_u == 66);
+}
+
+TEST_CASE("write complex data using pbf_builder: all") {
+    std::string buffer;
+    protozero::pbf_builder<TestComplex::Test> pw{buffer};
+    pw.add_fixed32(TestComplex::Test::required_fixed32_f, 12345678);
+
+    std::string submessage;
+    protozero::pbf_builder<TestComplex::Sub> pws{submessage};
+    pws.add_string(TestComplex::Sub::required_string_s, "foobar");
+    pw.add_message(TestComplex::Test::required_Sub_submessage, submessage);
+
+    pw.add_uint32(TestComplex::Test::repeated_uint32_u, 22);
+    pw.add_uint32(TestComplex::Test::repeated_uint32_u, 44);
+    pw.add_int64(TestComplex::Test::optional_int64_i, -9876543);
+    pw.add_uint32(TestComplex::Test::repeated_uint32_u, 44);
+    pw.add_uint32(TestComplex::Test::repeated_uint32_u, 66);
+    pw.add_uint32(TestComplex::Test::repeated_uint32_u, 66);
+
+    const int32_t d[] = { -17, 22 };
+    pw.add_packed_sint32(TestComplex::Test::packed_sint32_d, std::begin(d), std::end(d));
+
+    pw.add_int64(TestComplex::Test::optional_int64_j, 555555555);
+
+    protozero::pbf_reader item{buffer};
+
+    int number_of_u = 0;
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 12345678L);
+                break;
+            }
+            case 2: {
+                REQUIRE(true);
+                item.skip();
+                break;
+            }
+            case 3: {
+                REQUIRE(item.get_int64() == 555555555LL);
+                break;
+            }
+            case 4: {
+                item.skip();
+                ++number_of_u;
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            case 7: {
+                const auto pi = item.get_packed_sint32();
+                int32_t sum = 0;
+                for (auto val : pi) {
+                    sum += val;
+                }
+                REQUIRE(sum == 5);
+                break;
+            }
+            case 8: {
+                REQUIRE(item.get_string() == "optionalstring");
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+    REQUIRE(number_of_u == 5);
+}
+
+static void check_message(const std::string& buffer) {
+    protozero::pbf_reader item{buffer};
+
+    while (item.next()) {
+        switch (item.tag()) {
+            case 1: {
+                REQUIRE(item.get_fixed32() == 42L);
+                break;
+            }
+            case 5: {
+                protozero::pbf_reader subitem = item.get_message();
+                REQUIRE(subitem.next());
+                REQUIRE(subitem.get_string() == "foobar");
+                REQUIRE_FALSE(subitem.next());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should not be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("write complex with subwriter using pbf_writer") {
+    std::string buffer_test;
+    protozero::pbf_writer pbf_test{buffer_test};
+    pbf_test.add_fixed32(1, 42L);
+
+    SECTION("message in message") {
+        protozero::pbf_writer pbf_submessage{pbf_test, 5};
+        pbf_submessage.add_string(1, "foobar");
+    }
+
+    check_message(buffer_test);
+}
+
+TEST_CASE("write complex with subwriter using pbf_builder") {
+    std::string buffer_test;
+    protozero::pbf_builder<TestComplex::Test> pbf_test{buffer_test};
+    pbf_test.add_fixed32(TestComplex::Test::required_fixed32_f, 42L);
+
+    SECTION("message in message") {
+        protozero::pbf_builder<TestComplex::Sub> pbf_submessage{pbf_test, TestComplex::Test::required_Sub_submessage};
+        pbf_submessage.add_string(TestComplex::Sub::required_string_s, "foobar");
+    }
+
+    check_message(buffer_test);
+}
+
diff --git a/third_party/protozero/test/t/complex/testcase.cpp b/third_party/protozero/test/t/complex/testcase.cpp
new file mode 100644
index 00000000000..7d53e999ac4
--- /dev/null
+++ b/third_party/protozero/test/t/complex/testcase.cpp
@@ -0,0 +1,30 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestComplex::Test msg;
+
+    msg.set_f(12345678);
+    TestComplex::Sub* submsg = msg.mutable_submessage();
+    submsg->set_s("foobar");
+
+    write_to_file(msg, "data-minimal.pbf");
+
+    msg.add_u(22);
+    msg.add_u(44);
+    msg.set_i(-9876543);
+
+    write_to_file(msg, "data-some.pbf");
+
+    msg.set_s("optionalstring");
+    msg.add_u(44);
+    msg.add_u(66);
+    msg.add_u(66);
+    msg.add_d(-17);
+    msg.add_d(22);
+    msg.set_j(555555555);
+
+    write_to_file(msg, "data-all.pbf");
+}
+
diff --git a/third_party/protozero/test/t/complex/testcase.proto b/third_party/protozero/test/t/complex/testcase.proto
new file mode 100644
index 00000000000..26ebf0e3d17
--- /dev/null
+++ b/third_party/protozero/test/t/complex/testcase.proto
@@ -0,0 +1,19 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestComplex;
+
+message Sub {
+    required string s = 1;
+}
+
+message Test {
+    required fixed32 f = 1;
+    optional int64 i = 2;
+    optional int64 j = 3;
+    required Sub submessage = 5;
+    optional string s = 8;
+    repeated uint32 u = 4;
+    repeated sint32 d = 7 [packed=true];
+}
+
diff --git a/third_party/protozero/test/t/double/data-neg.pbf b/third_party/protozero/test/t/double/data-neg.pbf
new file mode 100644
index 00000000000..013e5e0c6b7
--- /dev/null
+++ b/third_party/protozero/test/t/double/data-neg.pbf
@@ -0,0 +1 @@
+	ףp=*��
\ No newline at end of file
diff --git a/third_party/protozero/test/t/double/data-pos.pbf b/third_party/protozero/test/t/double/data-pos.pbf
new file mode 100644
index 00000000000..42cdbd13430
--- /dev/null
+++ b/third_party/protozero/test/t/double/data-pos.pbf
@@ -0,0 +1 @@
+	�O��n�@
\ No newline at end of file
diff --git a/third_party/protozero/test/t/double/data-zero.pbf b/third_party/protozero/test/t/double/data-zero.pbf
new file mode 100644
index 00000000000..5f47e98c6bb
Binary files /dev/null and b/third_party/protozero/test/t/double/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/double/double_testcase.proto b/third_party/protozero/test/t/double/double_testcase.proto
new file mode 100644
index 00000000000..a4a4bf6dcd9
--- /dev/null
+++ b/third_party/protozero/test/t/double/double_testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestDouble;
+
+message Test {
+
+    required double x = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/double/reader_test_cases.cpp b/third_party/protozero/test/t/double/reader_test_cases.cpp
new file mode 100644
index 00000000000..4c22fcd8259
--- /dev/null
+++ b/third_party/protozero/test/t/double/reader_test_cases.cpp
@@ -0,0 +1,73 @@
+
+#include <test.hpp>
+
+TEST_CASE("read double field") {
+    // Run these tests twice, the second time we basically move the data
+    // one byte down in the buffer. It doesn't matter how the data or buffer
+    // is aligned before that, in at least one of these cases the double will
+    // not be aligned properly. So we test that even in that case the double
+    // will be extracted properly.
+    for (std::string::size_type n = 0; n < 2; ++n) {
+        std::string abuffer;
+        abuffer.reserve(1000);
+        abuffer.append(n, '\0');
+
+        SECTION("zero") {
+            abuffer.append(load_data("double/data-zero"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_double() == Approx(0.0));
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("positive") {
+            abuffer.append(load_data("double/data-pos"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_double() == Approx(4.893));
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("negative") {
+            abuffer.append(load_data("double/data-neg"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(item.get_double() == Approx(-9232.33));
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("end_of_buffer") {
+            abuffer.append(load_data("double/data-neg"));
+
+            for (std::string::size_type i = 1; i < abuffer.size() - n; ++i) {
+                protozero::pbf_reader item{abuffer.data() + n, i};
+                REQUIRE(item.next());
+                REQUIRE_THROWS_AS(item.get_double(), const protozero::end_of_buffer_exception&);
+            }
+        }
+    }
+}
+
+TEST_CASE("write double field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("zero") {
+        pw.add_double(1, 0.0);
+        REQUIRE(buffer == load_data("double/data-zero"));
+    }
+
+    SECTION("positive") {
+        pw.add_double(1, 4.893);
+        REQUIRE(buffer == load_data("double/data-pos"));
+    }
+
+    SECTION("negative") {
+        pw.add_double(1, -9232.33);
+        REQUIRE(buffer == load_data("double/data-neg"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/double/testcase.cpp b/third_party/protozero/test/t/double/testcase.cpp
new file mode 100644
index 00000000000..7e443779195
--- /dev/null
+++ b/third_party/protozero/test/t/double/testcase.cpp
@@ -0,0 +1,17 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestDouble::Test msg;
+
+    msg.set_x(0.0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_x(4.893);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_x(-9232.33);
+    write_to_file(msg, "data-neg.pbf");
+}
+
diff --git a/third_party/protozero/test/t/double/writer_test_cases.cpp b/third_party/protozero/test/t/double/writer_test_cases.cpp
new file mode 100644
index 00000000000..045adc120d4
--- /dev/null
+++ b/third_party/protozero/test/t/double/writer_test_cases.cpp
@@ -0,0 +1,38 @@
+
+#include <test.hpp>
+
+#include "t/double/double_testcase.pb.h"
+
+TEST_CASE("write double field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestDouble::Test msg;
+
+    SECTION("zero") {
+        pw.add_double(1, 0.0);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.x() == Approx(0.0));
+    }
+
+    SECTION("positive") {
+        pw.add_double(1, 4.893);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.x() == Approx(4.893));
+    }
+
+    SECTION("negative") {
+        pw.add_double(1, -9232.33);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.x() == Approx(-9232.33));
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/enum/data-black.pbf b/third_party/protozero/test/t/enum/data-black.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/enum/data-black.pbf differ
diff --git a/third_party/protozero/test/t/enum/data-blue.pbf b/third_party/protozero/test/t/enum/data-blue.pbf
new file mode 100644
index 00000000000..d65dd8f1d54
--- /dev/null
+++ b/third_party/protozero/test/t/enum/data-blue.pbf
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/third_party/protozero/test/t/enum/data-max.pbf b/third_party/protozero/test/t/enum/data-max.pbf
new file mode 100644
index 00000000000..f7d9ded026d
--- /dev/null
+++ b/third_party/protozero/test/t/enum/data-max.pbf
@@ -0,0 +1 @@
+����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/enum/data-min.pbf b/third_party/protozero/test/t/enum/data-min.pbf
new file mode 100644
index 00000000000..955e6a2aaee
--- /dev/null
+++ b/third_party/protozero/test/t/enum/data-min.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/enum/data-neg.pbf b/third_party/protozero/test/t/enum/data-neg.pbf
new file mode 100644
index 00000000000..1c2f041a6bc
--- /dev/null
+++ b/third_party/protozero/test/t/enum/data-neg.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/enum/enum_testcase.proto b/third_party/protozero/test/t/enum/enum_testcase.proto
new file mode 100644
index 00000000000..d99d7ee4fd0
--- /dev/null
+++ b/third_party/protozero/test/t/enum/enum_testcase.proto
@@ -0,0 +1,25 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestEnum;
+
+enum Color {
+    BLACK = 0;
+    RED   = 1;
+    GREEN = 2;
+    BLUE  = 3;
+    MAX   = 2147483646;
+    NEG   = -1;
+
+    // Older versions (before 2.6.0) of the google protobuf compiler have a
+    // bug and don't allow the real minimum of -2147483648, so we are testing
+    // with this.
+    MIN   = -2147483647;
+}
+
+message Test {
+
+    required Color color = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/enum/reader_test_cases.cpp b/third_party/protozero/test/t/enum/reader_test_cases.cpp
new file mode 100644
index 00000000000..026d1ed3dba
--- /dev/null
+++ b/third_party/protozero/test/t/enum/reader_test_cases.cpp
@@ -0,0 +1,83 @@
+
+#include <test.hpp>
+
+TEST_CASE("read enum field: zero") {
+    const std::string buffer = load_data("enum/data-black");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_enum() == 0L);
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read enum field: positive") {
+    const std::string buffer = load_data("enum/data-blue");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_enum() == 3L);
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read enum field: negative") {
+    const std::string buffer = load_data("enum/data-neg");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_enum() == -1L);
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read enum field: max") {
+    const std::string buffer = load_data("enum/data-max");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_enum() == std::numeric_limits<int32_t>::max());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read enum field: min") {
+    const std::string buffer = load_data("enum/data-min");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_enum() == (std::numeric_limits<int32_t>::min() + 1));
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("write enum field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("zero") {
+        pw.add_enum(1, 0L);
+        REQUIRE(buffer == load_data("enum/data-black"));
+    }
+
+    SECTION("positive") {
+        pw.add_enum(1, 3L);
+        REQUIRE(buffer == load_data("enum/data-blue"));
+    }
+
+    SECTION("negative") {
+        pw.add_enum(1, -1L);
+        REQUIRE(buffer == load_data("enum/data-neg"));
+    }
+
+    SECTION("max") {
+        pw.add_enum(1, std::numeric_limits<int32_t>::max());
+        REQUIRE(buffer == load_data("enum/data-max"));
+    }
+
+    SECTION("min") {
+        pw.add_enum(1, std::numeric_limits<int32_t>::min() + 1);
+        REQUIRE(buffer == load_data("enum/data-min"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/enum/testcase.cpp b/third_party/protozero/test/t/enum/testcase.cpp
new file mode 100644
index 00000000000..0854ff57040
--- /dev/null
+++ b/third_party/protozero/test/t/enum/testcase.cpp
@@ -0,0 +1,23 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestEnum::Test msg;
+
+    msg.set_color(TestEnum::BLACK);
+    write_to_file(msg, "data-black.pbf");
+
+    msg.set_color(TestEnum::BLUE);
+    write_to_file(msg, "data-blue.pbf");
+
+    msg.set_color(TestEnum::NEG);
+    write_to_file(msg, "data-neg.pbf");
+
+    msg.set_color(TestEnum::MAX);
+    write_to_file(msg, "data-max.pbf");
+
+    msg.set_color(TestEnum::MIN);
+    write_to_file(msg, "data-min.pbf");
+}
+
diff --git a/third_party/protozero/test/t/enum/writer_test_cases.cpp b/third_party/protozero/test/t/enum/writer_test_cases.cpp
new file mode 100644
index 00000000000..bf3e7c8a660
--- /dev/null
+++ b/third_party/protozero/test/t/enum/writer_test_cases.cpp
@@ -0,0 +1,54 @@
+
+#include <test.hpp>
+
+#include "t/enum/enum_testcase.pb.h"
+
+TEST_CASE("write enum field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestEnum::Test msg;
+
+    SECTION("zero") {
+        pw.add_enum(1, 0L);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.color() == TestEnum::Color::BLACK);
+    }
+
+    SECTION("positive") {
+        pw.add_enum(1, 3L);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.color() == TestEnum::Color::BLUE);
+    }
+
+    SECTION("negative") {
+        pw.add_enum(1, -1L);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.color() == TestEnum::Color::NEG);
+    }
+
+    SECTION("max") {
+        pw.add_enum(1, std::numeric_limits<int32_t>::max() - 1);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.color() == TestEnum::Color::MAX);
+    }
+
+    SECTION("min") {
+        pw.add_enum(1, std::numeric_limits<int32_t>::min() + 1);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.color() == TestEnum::Color::MIN);
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/fixed32/data-max.pbf b/third_party/protozero/test/t/fixed32/data-max.pbf
new file mode 100644
index 00000000000..416d363184c
--- /dev/null
+++ b/third_party/protozero/test/t/fixed32/data-max.pbf
@@ -0,0 +1 @@
+
����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/fixed32/data-pos.pbf b/third_party/protozero/test/t/fixed32/data-pos.pbf
new file mode 100644
index 00000000000..e63fa08fa0c
Binary files /dev/null and b/third_party/protozero/test/t/fixed32/data-pos.pbf differ
diff --git a/third_party/protozero/test/t/fixed32/data-pos200.pbf b/third_party/protozero/test/t/fixed32/data-pos200.pbf
new file mode 100644
index 00000000000..7dc726eab20
Binary files /dev/null and b/third_party/protozero/test/t/fixed32/data-pos200.pbf differ
diff --git a/third_party/protozero/test/t/fixed32/data-zero.pbf b/third_party/protozero/test/t/fixed32/data-zero.pbf
new file mode 100644
index 00000000000..1cf2c40c87e
Binary files /dev/null and b/third_party/protozero/test/t/fixed32/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/fixed32/fixed32_testcase.proto b/third_party/protozero/test/t/fixed32/fixed32_testcase.proto
new file mode 100644
index 00000000000..ab6334e6724
--- /dev/null
+++ b/third_party/protozero/test/t/fixed32/fixed32_testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestFixed32;
+
+message Test {
+
+    required fixed32 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/fixed32/reader_test_cases.cpp b/third_party/protozero/test/t/fixed32/reader_test_cases.cpp
new file mode 100644
index 00000000000..23cbf6c0802
--- /dev/null
+++ b/third_party/protozero/test/t/fixed32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE fixed32
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint32_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/fixed32/testcase.cpp b/third_party/protozero/test/t/fixed32/testcase.cpp
new file mode 100644
index 00000000000..450b78ad32f
--- /dev/null
+++ b/third_party/protozero/test/t/fixed32/testcase.cpp
@@ -0,0 +1,20 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestFixed32::Test msg;
+
+    msg.set_i(0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(std::numeric_limits<uint32_t>::max());
+    write_to_file(msg, "data-max.pbf");
+}
+
diff --git a/third_party/protozero/test/t/fixed32/writer_test_cases.cpp b/third_party/protozero/test/t/fixed32/writer_test_cases.cpp
new file mode 100644
index 00000000000..f4d5144a0a9
--- /dev/null
+++ b/third_party/protozero/test/t/fixed32/writer_test_cases.cpp
@@ -0,0 +1,38 @@
+
+#include <test.hpp>
+
+#include "t/fixed32/fixed32_testcase.pb.h"
+
+TEST_CASE("write fixed32 field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestFixed32::Test msg;
+
+    SECTION("zero") {
+        pw.add_fixed32(1, 0);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == 0);
+    }
+
+    SECTION("max") {
+        pw.add_fixed32(1, std::numeric_limits<uint32_t>::max());
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == std::numeric_limits<uint32_t>::max());
+    }
+
+    SECTION("min") {
+        pw.add_fixed32(1, std::numeric_limits<uint32_t>::min());
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == std::numeric_limits<uint32_t>::min());
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/fixed64/data-max.pbf b/third_party/protozero/test/t/fixed64/data-max.pbf
new file mode 100644
index 00000000000..cb810a5f484
--- /dev/null
+++ b/third_party/protozero/test/t/fixed64/data-max.pbf
@@ -0,0 +1 @@
+	��������
\ No newline at end of file
diff --git a/third_party/protozero/test/t/fixed64/data-pos.pbf b/third_party/protozero/test/t/fixed64/data-pos.pbf
new file mode 100644
index 00000000000..83f1583695d
Binary files /dev/null and b/third_party/protozero/test/t/fixed64/data-pos.pbf differ
diff --git a/third_party/protozero/test/t/fixed64/data-pos200.pbf b/third_party/protozero/test/t/fixed64/data-pos200.pbf
new file mode 100644
index 00000000000..be400ca7f37
Binary files /dev/null and b/third_party/protozero/test/t/fixed64/data-pos200.pbf differ
diff --git a/third_party/protozero/test/t/fixed64/data-zero.pbf b/third_party/protozero/test/t/fixed64/data-zero.pbf
new file mode 100644
index 00000000000..5f47e98c6bb
Binary files /dev/null and b/third_party/protozero/test/t/fixed64/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/fixed64/reader_test_cases.cpp b/third_party/protozero/test/t/fixed64/reader_test_cases.cpp
new file mode 100644
index 00000000000..9b613ba11b9
--- /dev/null
+++ b/third_party/protozero/test/t/fixed64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE fixed64
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint64_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/fixed64/testcase.cpp b/third_party/protozero/test/t/fixed64/testcase.cpp
new file mode 100644
index 00000000000..8c6daff632b
--- /dev/null
+++ b/third_party/protozero/test/t/fixed64/testcase.cpp
@@ -0,0 +1,20 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestFixed64::Test msg;
+
+    msg.set_i(0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(std::numeric_limits<uint64_t>::max());
+    write_to_file(msg, "data-max.pbf");
+}
+
diff --git a/third_party/protozero/test/t/fixed64/testcase.proto b/third_party/protozero/test/t/fixed64/testcase.proto
new file mode 100644
index 00000000000..6e3cce2a4b6
--- /dev/null
+++ b/third_party/protozero/test/t/fixed64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestFixed64;
+
+message Test {
+
+    required fixed64 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/float/data-neg.pbf b/third_party/protozero/test/t/float/data-neg.pbf
new file mode 100644
index 00000000000..4229a69c6f6
--- /dev/null
+++ b/third_party/protozero/test/t/float/data-neg.pbf
@@ -0,0 +1 @@
+
H�ڿ
\ No newline at end of file
diff --git a/third_party/protozero/test/t/float/data-pos.pbf b/third_party/protozero/test/t/float/data-pos.pbf
new file mode 100644
index 00000000000..c94c6df6356
--- /dev/null
+++ b/third_party/protozero/test/t/float/data-pos.pbf
@@ -0,0 +1 @@
+
H�@
\ No newline at end of file
diff --git a/third_party/protozero/test/t/float/data-zero.pbf b/third_party/protozero/test/t/float/data-zero.pbf
new file mode 100644
index 00000000000..1cf2c40c87e
Binary files /dev/null and b/third_party/protozero/test/t/float/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/float/reader_test_cases.cpp b/third_party/protozero/test/t/float/reader_test_cases.cpp
new file mode 100644
index 00000000000..f1891b0a4b0
--- /dev/null
+++ b/third_party/protozero/test/t/float/reader_test_cases.cpp
@@ -0,0 +1,74 @@
+
+#include <test.hpp>
+
+TEST_CASE("read float field") {
+    // Run these tests twice, the second time we basically move the data
+    // one byte down in the buffer. It doesn't matter how the data or buffer
+    // is aligned before that, in at least one of these cases the float will
+    // not be aligned properly. So we test that even in that case the float
+    // will be extracted properly.
+
+    for (std::string::size_type n = 0; n < 2; ++n) {
+        std::string abuffer;
+        abuffer.reserve(1000);
+        abuffer.append(n, '\0');
+
+        SECTION("zero") {
+            abuffer.append(load_data("float/data-zero"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(double(item.get_float()) == Approx(0.0));
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("positive") {
+            abuffer.append(load_data("float/data-pos"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(double(item.get_float()) == Approx(5.34));
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("negative") {
+            abuffer.append(load_data("float/data-neg"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            REQUIRE(double(item.get_float()) == Approx(-1.71));
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("end_of_buffer") {
+            abuffer.append(load_data("float/data-neg"));
+
+            for (std::string::size_type i = 1; i < abuffer.size() - n; ++i) {
+                protozero::pbf_reader item{abuffer.data() + n, i};
+                REQUIRE(item.next());
+                REQUIRE_THROWS_AS(item.get_float(), const protozero::end_of_buffer_exception&);
+            }
+        }
+    }
+}
+
+TEST_CASE("write float field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("zero") {
+        pw.add_float(1, 0.0f);
+        REQUIRE(buffer == load_data("float/data-zero"));
+    }
+
+    SECTION("positive") {
+        pw.add_float(1, 5.34f);
+        REQUIRE(buffer == load_data("float/data-pos"));
+    }
+
+    SECTION("negative") {
+        pw.add_float(1, -1.71f);
+        REQUIRE(buffer == load_data("float/data-neg"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/float/testcase.cpp b/third_party/protozero/test/t/float/testcase.cpp
new file mode 100644
index 00000000000..c7a743b5478
--- /dev/null
+++ b/third_party/protozero/test/t/float/testcase.cpp
@@ -0,0 +1,17 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestFloat::Test msg;
+
+    msg.set_x(0.0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_x(5.34);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_x(-1.71);
+    write_to_file(msg, "data-neg.pbf");
+}
+
diff --git a/third_party/protozero/test/t/float/testcase.proto b/third_party/protozero/test/t/float/testcase.proto
new file mode 100644
index 00000000000..db5d8b12233
--- /dev/null
+++ b/third_party/protozero/test/t/float/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestFloat;
+
+message Test {
+
+    required float x = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/int32/data-max.pbf b/third_party/protozero/test/t/int32/data-max.pbf
new file mode 100644
index 00000000000..f7d9ded026d
--- /dev/null
+++ b/third_party/protozero/test/t/int32/data-max.pbf
@@ -0,0 +1 @@
+����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/int32/data-min.pbf b/third_party/protozero/test/t/int32/data-min.pbf
new file mode 100644
index 00000000000..df5f9bd2d31
--- /dev/null
+++ b/third_party/protozero/test/t/int32/data-min.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int32/data-neg.pbf b/third_party/protozero/test/t/int32/data-neg.pbf
new file mode 100644
index 00000000000..1c2f041a6bc
--- /dev/null
+++ b/third_party/protozero/test/t/int32/data-neg.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int32/data-neg200.pbf b/third_party/protozero/test/t/int32/data-neg200.pbf
new file mode 100644
index 00000000000..29df43f4b99
--- /dev/null
+++ b/third_party/protozero/test/t/int32/data-neg200.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int32/data-pos.pbf b/third_party/protozero/test/t/int32/data-pos.pbf
new file mode 100644
index 00000000000..e19a122a540
--- /dev/null
+++ b/third_party/protozero/test/t/int32/data-pos.pbf
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int32/data-pos200.pbf b/third_party/protozero/test/t/int32/data-pos200.pbf
new file mode 100644
index 00000000000..d9eeb99052b
--- /dev/null
+++ b/third_party/protozero/test/t/int32/data-pos200.pbf
@@ -0,0 +1 @@
+�

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int32/data-zero.pbf b/third_party/protozero/test/t/int32/data-zero.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/int32/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/int32/int32_testcase.proto b/third_party/protozero/test/t/int32/int32_testcase.proto
new file mode 100644
index 00000000000..c80a4bddb28
--- /dev/null
+++ b/third_party/protozero/test/t/int32/int32_testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestInt32;
+
+message Test {
+
+    required int32 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/int32/reader_test_cases.cpp b/third_party/protozero/test/t/int32/reader_test_cases.cpp
new file mode 100644
index 00000000000..bd9492fc75e
--- /dev/null
+++ b/third_party/protozero/test/t/int32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE int32
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int32_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/int32/testcase.cpp b/third_party/protozero/test/t/int32/testcase.cpp
new file mode 100644
index 00000000000..f70711f26b7
--- /dev/null
+++ b/third_party/protozero/test/t/int32/testcase.cpp
@@ -0,0 +1,29 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestInt32::Test msg;
+
+    msg.set_i(0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(-1);
+    write_to_file(msg, "data-neg.pbf");
+
+    msg.set_i(-200);
+    write_to_file(msg, "data-neg200.pbf");
+
+    msg.set_i(std::numeric_limits<int32_t>::max());
+    write_to_file(msg, "data-max.pbf");
+
+    msg.set_i(std::numeric_limits<int32_t>::min());
+    write_to_file(msg, "data-min.pbf");
+}
+
diff --git a/third_party/protozero/test/t/int32/writer_test_cases.cpp b/third_party/protozero/test/t/int32/writer_test_cases.cpp
new file mode 100644
index 00000000000..40b982f31f8
--- /dev/null
+++ b/third_party/protozero/test/t/int32/writer_test_cases.cpp
@@ -0,0 +1,54 @@
+
+#include <test.hpp>
+
+#include "t/int32/int32_testcase.pb.h"
+
+TEST_CASE("write int32 field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestInt32::Test msg;
+
+    SECTION("zero") {
+        pw.add_int32(1, 0L);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == 0L);
+    }
+
+    SECTION("positive") {
+        pw.add_int32(1, 1L);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == 1L);
+    }
+
+    SECTION("negative") {
+        pw.add_int32(1, -1L);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == -1L);
+    }
+
+    SECTION("max") {
+        pw.add_int32(1, std::numeric_limits<int32_t>::max());
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == std::numeric_limits<int32_t>::max());
+    }
+
+    SECTION("min") {
+        pw.add_int32(1, std::numeric_limits<int32_t>::min());
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i() == std::numeric_limits<int32_t>::min());
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/int64/data-max.pbf b/third_party/protozero/test/t/int64/data-max.pbf
new file mode 100644
index 00000000000..e6fd4b519c5
--- /dev/null
+++ b/third_party/protozero/test/t/int64/data-max.pbf
@@ -0,0 +1 @@
+��������
\ No newline at end of file
diff --git a/third_party/protozero/test/t/int64/data-min.pbf b/third_party/protozero/test/t/int64/data-min.pbf
new file mode 100644
index 00000000000..ee99dcc897f
--- /dev/null
+++ b/third_party/protozero/test/t/int64/data-min.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int64/data-neg.pbf b/third_party/protozero/test/t/int64/data-neg.pbf
new file mode 100644
index 00000000000..1c2f041a6bc
--- /dev/null
+++ b/third_party/protozero/test/t/int64/data-neg.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int64/data-neg200.pbf b/third_party/protozero/test/t/int64/data-neg200.pbf
new file mode 100644
index 00000000000..29df43f4b99
--- /dev/null
+++ b/third_party/protozero/test/t/int64/data-neg200.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int64/data-pos.pbf b/third_party/protozero/test/t/int64/data-pos.pbf
new file mode 100644
index 00000000000..e19a122a540
--- /dev/null
+++ b/third_party/protozero/test/t/int64/data-pos.pbf
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int64/data-pos200.pbf b/third_party/protozero/test/t/int64/data-pos200.pbf
new file mode 100644
index 00000000000..d9eeb99052b
--- /dev/null
+++ b/third_party/protozero/test/t/int64/data-pos200.pbf
@@ -0,0 +1 @@
+�

\ No newline at end of file
diff --git a/third_party/protozero/test/t/int64/data-zero.pbf b/third_party/protozero/test/t/int64/data-zero.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/int64/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/int64/reader_test_cases.cpp b/third_party/protozero/test/t/int64/reader_test_cases.cpp
new file mode 100644
index 00000000000..897710396bf
--- /dev/null
+++ b/third_party/protozero/test/t/int64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE int64
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int64_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/int64/testcase.cpp b/third_party/protozero/test/t/int64/testcase.cpp
new file mode 100644
index 00000000000..ce09789550f
--- /dev/null
+++ b/third_party/protozero/test/t/int64/testcase.cpp
@@ -0,0 +1,29 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestInt64::Test msg;
+
+    msg.set_i(0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(-1);
+    write_to_file(msg, "data-neg.pbf");
+
+    msg.set_i(-200);
+    write_to_file(msg, "data-neg200.pbf");
+
+    msg.set_i(std::numeric_limits<int64_t>::max());
+    write_to_file(msg, "data-max.pbf");
+
+    msg.set_i(std::numeric_limits<int64_t>::min());
+    write_to_file(msg, "data-min.pbf");
+}
+
diff --git a/third_party/protozero/test/t/int64/testcase.proto b/third_party/protozero/test/t/int64/testcase.proto
new file mode 100644
index 00000000000..61a297549ff
--- /dev/null
+++ b/third_party/protozero/test/t/int64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestInt64;
+
+message Test {
+
+    required int64 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/message/data-message.pbf b/third_party/protozero/test/t/message/data-message.pbf
new file mode 100644
index 00000000000..7a002fbd10f
--- /dev/null
+++ b/third_party/protozero/test/t/message/data-message.pbf
@@ -0,0 +1,3 @@
+
+
+foobar
\ No newline at end of file
diff --git a/third_party/protozero/test/t/message/data-opt-element.pbf b/third_party/protozero/test/t/message/data-opt-element.pbf
new file mode 100644
index 00000000000..d60b0ab544e
--- /dev/null
+++ b/third_party/protozero/test/t/message/data-opt-element.pbf
@@ -0,0 +1,2 @@
+
+optional
\ No newline at end of file
diff --git a/third_party/protozero/test/t/message/data-opt-empty.pbf b/third_party/protozero/test/t/message/data-opt-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/message/message_testcase.proto b/third_party/protozero/test/t/message/message_testcase.proto
new file mode 100644
index 00000000000..eee38ef2f3e
--- /dev/null
+++ b/third_party/protozero/test/t/message/message_testcase.proto
@@ -0,0 +1,17 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestMessage;
+
+message Sub {
+    required string s = 1;
+}
+
+message Test {
+    required Sub submessage = 1;
+}
+
+message Opt {
+    optional string s = 1;
+}
+
diff --git a/third_party/protozero/test/t/message/reader_test_cases.cpp b/third_party/protozero/test/t/message/reader_test_cases.cpp
new file mode 100644
index 00000000000..04e4e7d3bee
--- /dev/null
+++ b/third_party/protozero/test/t/message/reader_test_cases.cpp
@@ -0,0 +1,129 @@
+
+#include <test.hpp>
+
+TEST_CASE("read message field: string") {
+    const std::string buffer = load_data("message/data-message");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    protozero::pbf_reader subitem{item.get_message()};
+    REQUIRE_FALSE(item.next());
+
+    REQUIRE(subitem.next());
+    REQUIRE(subitem.get_string() == "foobar");
+    REQUIRE_FALSE(subitem.next());
+}
+
+TEST_CASE("read message field: end of buffer") {
+    const std::string buffer = load_data("message/data-message");
+
+    for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+        protozero::pbf_reader item{buffer.data(), i};
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.get_string(), const protozero::end_of_buffer_exception&);
+    }
+}
+
+TEST_CASE("read message field: optional contents of message - empty") {
+    const std::string buffer = load_data("message/data-opt-empty");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read message field: string opt") {
+    const std::string buffer = load_data("message/data-opt-element");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_string() == "optional");
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("write message field") {
+    std::string buffer;
+    protozero::pbf_writer pbf_test{buffer};
+
+    SECTION("string") {
+        std::string buffer_submessage;
+        protozero::pbf_writer pbf_submessage{buffer_submessage};
+        pbf_submessage.add_string(1, "foobar");
+
+        pbf_test.add_message(1, buffer_submessage);
+    }
+
+    SECTION("string with subwriter") {
+        protozero::pbf_writer pbf_submessage{pbf_test, 1};
+        pbf_submessage.add_string(1, "foobar");
+    }
+
+    SECTION("string with subwriter with reserved size") {
+        std::string str{"foobar"};
+        const auto size = 1 /* tag */ + 1 /* length field */ + str.size();
+        protozero::pbf_writer pbf_submessage{pbf_test, 1, size};
+        pbf_submessage.add_string(1, "foobar");
+    }
+
+    REQUIRE(buffer == load_data("message/data-message"));
+}
+
+TEST_CASE("write message field into non-empty buffer") {
+    std::string buffer{"some data already in here"};
+    protozero::pbf_writer pbf_test{buffer};
+
+    SECTION("string") {
+        std::string buffer_submessage;
+        protozero::pbf_writer pbf_submessage{buffer_submessage};
+        pbf_submessage.add_string(1, "foobar");
+
+        pbf_test.add_message(1, buffer_submessage);
+    }
+
+    SECTION("string with subwriter") {
+        protozero::pbf_writer pbf_submessage{pbf_test, 1};
+        pbf_submessage.add_string(1, "foobar");
+    }
+
+    REQUIRE(buffer == std::string{"some data already in here"} + load_data("message/data-message"));
+}
+
+TEST_CASE("write message field reserving memory beforehand") {
+    std::string buffer;
+    protozero::pbf_writer pbf_test{buffer};
+    pbf_test.reserve(100);
+    REQUIRE(buffer.capacity() >= 100);
+
+    SECTION("string") {
+        std::string buffer_submessage;
+        protozero::pbf_writer pbf_submessage{buffer_submessage};
+        pbf_submessage.add_string(1, "foobar");
+
+        pbf_test.add_message(1, buffer_submessage);
+    }
+
+    SECTION("string with subwriter") {
+        protozero::pbf_writer pbf_submessage{pbf_test, 1};
+        pbf_submessage.add_string(1, "foobar");
+    }
+
+    REQUIRE(buffer == load_data("message/data-message"));
+}
+
+TEST_CASE("write optional message field") {
+    std::string buffer;
+    protozero::pbf_writer pbf_opt{buffer};
+
+    SECTION("add nothing") {
+        REQUIRE(buffer == load_data("message/data-opt-empty"));
+    }
+
+    SECTION("add string") {
+        pbf_opt.add_string(1, "optional");
+
+        REQUIRE(buffer == load_data("message/data-opt-element"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/message/testcase.cpp b/third_party/protozero/test/t/message/testcase.cpp
new file mode 100644
index 00000000000..f25286f6f43
--- /dev/null
+++ b/third_party/protozero/test/t/message/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestMessage::Test msg;
+
+    TestMessage::Sub* submsg = msg.mutable_submessage();
+    submsg->set_s("foobar");
+
+    write_to_file(msg, "data-message.pbf");
+
+    TestMessage::Opt opt_msg;
+    write_to_file(opt_msg, "data-opt-empty.pbf");
+
+    opt_msg.set_s("optional");
+    write_to_file(opt_msg, "data-opt-element.pbf");
+}
+
diff --git a/third_party/protozero/test/t/message/writer_test_cases.cpp b/third_party/protozero/test/t/message/writer_test_cases.cpp
new file mode 100644
index 00000000000..98d8a913bcb
--- /dev/null
+++ b/third_party/protozero/test/t/message/writer_test_cases.cpp
@@ -0,0 +1,29 @@
+
+#include <test.hpp>
+
+#include "t/message/message_testcase.pb.h"
+
+TEST_CASE("write message field and check with libprotobuf") {
+
+    std::string buffer_test;
+    protozero::pbf_writer pbf_test{buffer_test};
+
+    SECTION("string") {
+        std::string buffer_submessage;
+        protozero::pbf_writer pbf_submessage{buffer_submessage};
+        pbf_submessage.add_string(1, "foobar");
+
+        pbf_test.add_message(1, buffer_submessage);
+    }
+
+    SECTION("string with subwriter") {
+        protozero::pbf_writer pbf_submessage{pbf_test, 1};
+        pbf_submessage.add_string(1, "foobar");
+    }
+
+    TestMessage::Test msg;
+    msg.ParseFromString(buffer_test);
+    REQUIRE(msg.submessage().s() == "foobar");
+
+}
+
diff --git a/third_party/protozero/test/t/nested/data-message.pbf b/third_party/protozero/test/t/nested/data-message.pbf
new file mode 100644
index 00000000000..6856641a6ef
--- /dev/null
+++ b/third_party/protozero/test/t/nested/data-message.pbf
@@ -0,0 +1,5 @@
+
+
+
+
+foobarcXM
\ No newline at end of file
diff --git a/third_party/protozero/test/t/nested/data-no-message.pbf b/third_party/protozero/test/t/nested/data-no-message.pbf
new file mode 100644
index 00000000000..82be04054b9
Binary files /dev/null and b/third_party/protozero/test/t/nested/data-no-message.pbf differ
diff --git a/third_party/protozero/test/t/nested/nested_testcase.proto b/third_party/protozero/test/t/nested/nested_testcase.proto
new file mode 100644
index 00000000000..022737bed58
--- /dev/null
+++ b/third_party/protozero/test/t/nested/nested_testcase.proto
@@ -0,0 +1,20 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestNested;
+
+message SubSub {
+    optional string s = 1;
+    optional int32 i = 2;
+}
+
+message Sub {
+    optional SubSub subsub = 1;
+    optional int32 i = 2;
+}
+
+message Test {
+    optional Sub sub = 1;
+    optional int32 i = 2;
+}
+
diff --git a/third_party/protozero/test/t/nested/reader_test_cases.cpp b/third_party/protozero/test/t/nested/reader_test_cases.cpp
new file mode 100644
index 00000000000..0c35d53e91a
--- /dev/null
+++ b/third_party/protozero/test/t/nested/reader_test_cases.cpp
@@ -0,0 +1,157 @@
+
+#include <test.hpp>
+
+inline void check_subsub(protozero::pbf_reader message) {
+    while (message.next()) {
+        switch (message.tag()) {
+            case 1: {
+                REQUIRE("foobar" == message.get_string());
+                break;
+            }
+            case 2: {
+                REQUIRE(99 == message.get_int32());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should never be here
+                break;
+            }
+        }
+    }
+}
+
+inline void check_sub(protozero::pbf_reader message) {
+    while (message.next()) {
+        switch (message.tag()) {
+            case 1: {
+                check_subsub(message.get_message());
+                break;
+            }
+            case 2: {
+                REQUIRE(88 == message.get_int32());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should never be here
+                break;
+            }
+        }
+    }
+}
+
+inline void check(protozero::pbf_reader message) {
+    while (message.next()) {
+        switch (message.tag()) {
+            case 1: {
+                check_sub(message.get_message());
+                break;
+            }
+            case 2: {
+                REQUIRE(77 == message.get_int32());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should never be here
+                break;
+            }
+        }
+    }
+}
+
+inline void check_empty(protozero::pbf_reader message) {
+    while (message.next()) {
+        switch (message.tag()) {
+            case 1: {
+                REQUIRE_FALSE(message.get_message().next());
+                break;
+            }
+            case 2: {
+                REQUIRE(77 == message.get_int32());
+                break;
+            }
+            default: {
+                REQUIRE(false); // should never be here
+                break;
+            }
+        }
+    }
+}
+
+TEST_CASE("read nested message fields: string") {
+    const std::string buffer = load_data("nested/data-message");
+
+    protozero::pbf_reader message{buffer};
+    check(message);
+}
+
+TEST_CASE("read nested message fields: no submessage") {
+    const std::string buffer = load_data("nested/data-no-message");
+
+    protozero::pbf_reader message{buffer};
+    check_empty(message);
+}
+
+TEST_CASE("write nested message fields") {
+    std::string buffer_test;
+    protozero::pbf_writer pbf_test{buffer_test};
+
+    SECTION("string") {
+        std::string buffer_subsub;
+        protozero::pbf_writer pbf_subsub{buffer_subsub};
+        pbf_subsub.add_string(1, "foobar");
+        pbf_subsub.add_int32(2, 99);
+
+        std::string buffer_sub;
+        protozero::pbf_writer pbf_sub{buffer_sub};
+        pbf_sub.add_string(1, buffer_subsub);
+        pbf_sub.add_int32(2, 88);
+
+        pbf_test.add_message(1, buffer_sub);
+    }
+
+    SECTION("string with subwriter") {
+        protozero::pbf_writer pbf_sub{pbf_test, 1};
+        {
+            protozero::pbf_writer pbf_subsub{pbf_sub, 1};
+            pbf_subsub.add_string(1, "foobar");
+            pbf_subsub.add_int32(2, 99);
+        }
+        pbf_sub.add_int32(2, 88);
+    }
+
+    pbf_test.add_int32(2, 77);
+
+    protozero::pbf_reader message{buffer_test};
+    check(message);
+}
+
+TEST_CASE("write nested message fields - no message") {
+    std::string buffer_test;
+    protozero::pbf_writer pbf_test{buffer_test};
+
+    SECTION("nothing") {
+    }
+
+    SECTION("empty string") {
+        std::string buffer_sub;
+
+        pbf_test.add_message(1, buffer_sub);
+    }
+
+    SECTION("string with pbf_writer") {
+        std::string buffer_sub;
+        protozero::pbf_writer pbf_sub{buffer_sub};
+
+        pbf_test.add_message(1, buffer_sub);
+    }
+
+    SECTION("string with subwriter") {
+        protozero::pbf_writer pbf_sub{pbf_test, 1};
+    }
+
+    pbf_test.add_int32(2, 77);
+
+    protozero::pbf_reader message{buffer_test};
+    check_empty(message);
+}
+
diff --git a/third_party/protozero/test/t/nested/testcase.cpp b/third_party/protozero/test/t/nested/testcase.cpp
new file mode 100644
index 00000000000..8a11b3fd740
--- /dev/null
+++ b/third_party/protozero/test/t/nested/testcase.cpp
@@ -0,0 +1,21 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestNested::Test msg;
+    msg.set_i(77);
+
+    TestNested::Sub* sub = msg.mutable_sub();
+
+    write_to_file(msg, "data-no-message.pbf");
+
+    sub->set_i(88);
+
+    TestNested::SubSub* subsub = sub->mutable_subsub();
+    subsub->set_s("foobar");
+    subsub->set_i(99);
+
+    write_to_file(msg, "data-message.pbf");
+}
+
diff --git a/third_party/protozero/test/t/nested/writer_test_cases.cpp b/third_party/protozero/test/t/nested/writer_test_cases.cpp
new file mode 100644
index 00000000000..265410c7109
--- /dev/null
+++ b/third_party/protozero/test/t/nested/writer_test_cases.cpp
@@ -0,0 +1,46 @@
+
+#include <test.hpp>
+
+#include "t/nested/nested_testcase.pb.h"
+
+TEST_CASE("write nested message fields and check with libprotobuf") {
+
+    std::string buffer_test;
+    protozero::pbf_writer pbf_test{buffer_test};
+
+    SECTION("string") {
+        std::string buffer_subsub;
+        protozero::pbf_writer pbf_subsub{buffer_subsub};
+        pbf_subsub.add_string(1, "foobar");
+        pbf_subsub.add_int32(2, 99);
+
+        std::string buffer_sub;
+        protozero::pbf_writer pbf_sub{buffer_sub};
+        pbf_sub.add_string(1, buffer_subsub);
+        pbf_sub.add_int32(2, 88);
+
+        pbf_test.add_message(1, buffer_sub);
+    }
+
+    SECTION("with subwriter") {
+        protozero::pbf_writer pbf_sub{pbf_test, 1};
+        {
+            protozero::pbf_writer pbf_subsub(pbf_sub, 1);
+            pbf_subsub.add_string(1, "foobar");
+            pbf_subsub.add_int32(2, 99);
+        }
+        pbf_sub.add_int32(2, 88);
+    }
+
+    pbf_test.add_int32(2, 77);
+
+    TestNested::Test msg;
+    msg.ParseFromString(buffer_test);
+
+    REQUIRE(msg.i() == 77);
+    REQUIRE(msg.sub().i() == 88);
+    REQUIRE(msg.sub().subsub().i() == 99);
+    REQUIRE(msg.sub().subsub().s() == "foobar");
+
+}
+
diff --git a/third_party/protozero/test/t/repeated/data-empty.pbf b/third_party/protozero/test/t/repeated/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated/data-many.pbf b/third_party/protozero/test/t/repeated/data-many.pbf
new file mode 100644
index 00000000000..39476f4005e
Binary files /dev/null and b/third_party/protozero/test/t/repeated/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated/data-one.pbf b/third_party/protozero/test/t/repeated/data-one.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/repeated/data-one.pbf differ
diff --git a/third_party/protozero/test/t/repeated/reader_test_cases.cpp b/third_party/protozero/test/t/repeated/reader_test_cases.cpp
new file mode 100644
index 00000000000..8fb17c49d5b
--- /dev/null
+++ b/third_party/protozero/test/t/repeated/reader_test_cases.cpp
@@ -0,0 +1,74 @@
+
+#include <test.hpp>
+
+TEST_CASE("read repeated fields: empty") {
+    const std::string buffer = load_data("repeated/data-empty");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read repeated fields: one") {
+    const std::string buffer = load_data("repeated/data-one");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_int32() == 0L);
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read repeated fields: many") {
+    const std::string buffer = load_data("repeated/data-many");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_int32() == 0L);
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_int32() == 1L);
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_int32() == -1L);
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_int32() == std::numeric_limits<int32_t>::max());
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_int32() == std::numeric_limits<int32_t>::min());
+
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read repeated fields: end of buffer") {
+    const std::string buffer = load_data("repeated/data-one");
+
+    for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+        protozero::pbf_reader item{buffer.data(), i};
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.get_int32(), const protozero::end_of_buffer_exception&);
+    }
+}
+
+TEST_CASE("write repeated fields") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("one") {
+        pw.add_int32(1, 0L);
+        REQUIRE(buffer == load_data("repeated/data-one"));
+    }
+
+    SECTION("many") {
+        pw.add_int32(1, 0L);
+        pw.add_int32(1, 1L);
+        pw.add_int32(1, -1L);
+        pw.add_int32(1, std::numeric_limits<int32_t>::max());
+        pw.add_int32(1, std::numeric_limits<int32_t>::min());
+
+        REQUIRE(buffer == load_data("repeated/data-many"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/repeated/repeated_testcase.proto b/third_party/protozero/test/t/repeated/repeated_testcase.proto
new file mode 100644
index 00000000000..a6f95d2b991
--- /dev/null
+++ b/third_party/protozero/test/t/repeated/repeated_testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeated;
+
+message Test {
+
+    repeated int32 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/repeated/testcase.cpp b/third_party/protozero/test/t/repeated/testcase.cpp
new file mode 100644
index 00000000000..f86525ac682
--- /dev/null
+++ b/third_party/protozero/test/t/repeated/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeated::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(0);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(1);
+    msg.add_i(-1);
+    msg.add_i(std::numeric_limits<int32_t>::max());
+    msg.add_i(std::numeric_limits<int32_t>::min());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated/writer_test_cases.cpp b/third_party/protozero/test/t/repeated/writer_test_cases.cpp
new file mode 100644
index 00000000000..6aaab1ab35f
--- /dev/null
+++ b/third_party/protozero/test/t/repeated/writer_test_cases.cpp
@@ -0,0 +1,40 @@
+
+#include <test.hpp>
+
+#include "t/repeated/repeated_testcase.pb.h"
+
+TEST_CASE("write repeated fields and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestRepeated::Test msg;
+
+    SECTION("one") {
+        pw.add_int32(1, 0L);
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i().size() == 1);
+        REQUIRE(msg.i(0) == 0L);
+    }
+
+    SECTION("many") {
+        pw.add_int32(1, 0L);
+        pw.add_int32(1, 1L);
+        pw.add_int32(1, -1L);
+        pw.add_int32(1, std::numeric_limits<int32_t>::max());
+        pw.add_int32(1, std::numeric_limits<int32_t>::min());
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i().size() == 5);
+        REQUIRE(msg.i(0) == 0L);
+        REQUIRE(msg.i(1) == 1L);
+        REQUIRE(msg.i(2) == -1L);
+        REQUIRE(msg.i(3) == std::numeric_limits<int32_t>::max());
+        REQUIRE(msg.i(4) == std::numeric_limits<int32_t>::min());
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_bool/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_bool/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_bool/data-many.pbf b/third_party/protozero/test/t/repeated_packed_bool/data-many.pbf
new file mode 100644
index 00000000000..0753ca79f20
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_bool/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_bool/data-one.pbf b/third_party/protozero/test/t/repeated_packed_bool/data-one.pbf
new file mode 100644
index 00000000000..160742634d8
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_bool/data-one.pbf
@@ -0,0 +1,2 @@
+
+


\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_bool/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_bool/reader_test_cases.cpp
new file mode 100644
index 00000000000..60b7c65cd7c
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_bool/reader_test_cases.cpp
@@ -0,0 +1,156 @@
+
+#include <test.hpp>
+
+TEST_CASE("read repeated packed bool field: empty") {
+    const std::string buffer = load_data("repeated_packed_bool/data-empty");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read repeated packed bool field: one") {
+    const std::string buffer = load_data("repeated_packed_bool/data-one");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    const auto it_range = item.get_packed_bool();
+    REQUIRE(std::distance(it_range.begin(), it_range.end()) == 1);
+    REQUIRE(it_range.size() == 1);
+    REQUIRE_FALSE(item.next());
+
+    REQUIRE(it_range.begin() != it_range.end());
+    REQUIRE(*it_range.begin());
+    REQUIRE(std::next(it_range.begin()) == it_range.end());
+}
+
+TEST_CASE("read repeated packed bool field: many") {
+    const std::string buffer = load_data("repeated_packed_bool/data-many");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    const auto it_range = item.get_packed_bool();
+    REQUIRE(std::distance(it_range.begin(), it_range.end()) == 4);
+    REQUIRE(it_range.size() == 4);
+    REQUIRE_FALSE(item.next());
+
+    auto it = it_range.begin();
+    REQUIRE(it != it_range.end());
+    REQUIRE(*it++);
+    REQUIRE(*it++);
+    REQUIRE_FALSE(*it++);
+    REQUIRE(*it++);
+    REQUIRE(it == it_range.end());
+}
+
+TEST_CASE("read repeated packed bool field: end of buffer") {
+    const std::string buffer = load_data("repeated_packed_bool/data-many");
+
+    for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+        protozero::pbf_reader item{buffer.data(), i};
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.get_packed_bool(), const protozero::end_of_buffer_exception&);
+    }
+}
+
+TEST_CASE("write repeated packed bool field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty") {
+        const bool data[] = { true };
+        pw.add_packed_bool(1, std::begin(data), std::begin(data) /* !!!! */);
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-empty"));
+    }
+
+    SECTION("one") {
+        const bool data[] = { true };
+        pw.add_packed_bool(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-one"));
+    }
+
+    SECTION("many") {
+        const bool data[] = { true, true, false, true };
+        pw.add_packed_bool(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-many"));
+    }
+
+}
+
+TEST_CASE("write repeated packed bool field using packed_field_bool") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty - should do rollback") {
+        {
+            protozero::packed_field_bool field{pw, 1};
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-empty"));
+    }
+
+    SECTION("one") {
+        {
+            protozero::packed_field_bool field{pw, 1};
+            field.add_element(true);
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-one"));
+    }
+
+    SECTION("many") {
+        {
+            protozero::packed_field_bool field{pw, 1};
+            field.add_element(true);
+            field.add_element(true);
+            field.add_element(false);
+            field.add_element(true);
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-many"));
+    }
+}
+
+TEST_CASE("write repeated packed bool field using packed_field_bool with pbf_builder") {
+    enum class msg : protozero::pbf_tag_type {
+        f = 1
+    };
+
+    std::string buffer;
+    protozero::pbf_builder<msg> pw{buffer};
+
+    SECTION("empty - should do rollback") {
+        {
+            protozero::packed_field_bool field{pw, msg::f};
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-empty"));
+    }
+
+    SECTION("one") {
+        {
+            protozero::packed_field_bool field{pw, msg::f};
+            field.add_element(true);
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-one"));
+    }
+
+    SECTION("many") {
+        {
+            protozero::packed_field_bool field{pw, msg::f};
+            field.add_element(true);
+            field.add_element(true);
+            field.add_element(false);
+            field.add_element(true);
+        }
+
+        REQUIRE(buffer == load_data("repeated_packed_bool/data-many"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_bool/testcase.cpp b/third_party/protozero/test/t/repeated_packed_bool/testcase.cpp
new file mode 100644
index 00000000000..df7b8761dd4
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_bool/testcase.cpp
@@ -0,0 +1,18 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedBool::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_b(true);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_b(true);
+    msg.add_b(false);
+    msg.add_b(true);
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_bool/testcase.proto b/third_party/protozero/test/t/repeated_packed_bool/testcase.proto
new file mode 100644
index 00000000000..53428aeb268
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_bool/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedBool;
+
+message Test {
+
+    repeated bool b = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_double/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_double/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_double/data-many.pbf b/third_party/protozero/test/t/repeated_packed_double/data-many.pbf
new file mode 100644
index 00000000000..b5ba733a406
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_double/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_double/data-one.pbf b/third_party/protozero/test/t/repeated_packed_double/data-one.pbf
new file mode 100644
index 00000000000..3c9ac4ba7f5
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_double/data-one.pbf
@@ -0,0 +1,3 @@
+
+ףp=
+W1@
\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_double/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_double/reader_test_cases.cpp
new file mode 100644
index 00000000000..35b015cd3d5
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_double/reader_test_cases.cpp
@@ -0,0 +1,116 @@
+
+#include <test.hpp>
+
+TEST_CASE("read repeated packed double field") {
+    // Run these tests twice, the second time we basically move the data
+    // one byte down in the buffer. It doesn't matter how the data or buffer
+    // is aligned before that, in at least one of these cases the doubles will
+    // not be aligned properly. So we test that even in that case the doubles
+    // will be extracted properly.
+
+    for (std::string::size_type n = 0; n < 2; ++n) {
+        std::string abuffer;
+        abuffer.reserve(1000);
+        abuffer.append(n, '\0');
+
+        SECTION("empty") {
+            abuffer.append(load_data("repeated_packed_double/data-empty"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("one") {
+            abuffer.append(load_data("repeated_packed_double/data-one"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            const auto it_range = item.get_packed_double();
+            REQUIRE_FALSE(item.next());
+
+            REQUIRE(*it_range.begin() == Approx(17.34));
+            REQUIRE(std::next(it_range.begin()) == it_range.end());
+        }
+
+        SECTION("many") {
+            abuffer.append(load_data("repeated_packed_double/data-many"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            const auto it_range = item.get_packed_double();
+            REQUIRE_FALSE(item.next());
+
+            auto it = it_range.begin();
+            REQUIRE(*it++ == Approx(17.34));
+            REQUIRE(*it++ == Approx( 0.0));
+            REQUIRE(*it++ == Approx( 1.0));
+            REQUIRE(*it++ == std::numeric_limits<double>::min());
+            REQUIRE(*it++ == std::numeric_limits<double>::max());
+            REQUIRE(it == it_range.end());
+
+            it = it_range.begin();
+            auto it2 = it + 1;
+            REQUIRE(it2 > it);
+            REQUIRE(it < it2);
+            REQUIRE(it <= it_range.begin());
+            REQUIRE(it >= it_range.begin());
+            REQUIRE(*it2 == Approx(0.0));
+            auto it3 = 1 + it;
+            REQUIRE(*it3 == Approx(0.0));
+            auto it4 = it2 - 1;
+            REQUIRE(*it4 == Approx(17.34));
+            it4 += 2;
+            REQUIRE(*it4 == Approx(1.0));
+            it4 -= 2;
+            REQUIRE(*it4 == Approx(17.34));
+            it4 += 2;
+            REQUIRE(*it4 == Approx(1.0));
+            REQUIRE(*it4-- == Approx(1.0));
+            REQUIRE(*it4 == Approx(0.0));
+            REQUIRE(*--it4 == Approx(17.34));
+            REQUIRE(it4[0] == Approx(17.34));
+            REQUIRE(it4[1] == Approx(0.0));
+            REQUIRE(std::distance(it_range.begin(), it_range.end()) == 5);
+            REQUIRE(it_range.end() - it_range.begin() == 5);
+            REQUIRE(it_range.begin() - it_range.end() == -5);
+
+        }
+
+        SECTION("end_of_buffer") {
+            abuffer.append(load_data("repeated_packed_double/data-many"));
+
+            for (std::string::size_type i = 1; i < abuffer.size() - n; ++i) {
+                protozero::pbf_reader item{abuffer.data() + n, i};
+                REQUIRE(item.next());
+                REQUIRE_THROWS_AS(item.get_packed_double(), const protozero::end_of_buffer_exception&);
+            }
+        }
+    }
+}
+
+TEST_CASE("write repeated packed double field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty") {
+        const double data[] = { 17.34 };
+        pw.add_packed_double(1, std::begin(data), std::begin(data) /* !!!! */);
+
+        REQUIRE(buffer == load_data("repeated_packed_double/data-empty"));
+    }
+
+    SECTION("one") {
+        const double data[] = { 17.34 };
+        pw.add_packed_double(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_double/data-one"));
+    }
+
+    SECTION("many") {
+        const double data[] = { 17.34, 0.0, 1.0, std::numeric_limits<double>::min(), std::numeric_limits<double>::max() };
+        pw.add_packed_double(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_double/data-many"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_double/testcase.cpp b/third_party/protozero/test/t/repeated_packed_double/testcase.cpp
new file mode 100644
index 00000000000..21d2e8ad5fb
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_double/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedDouble::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_d(17.34);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_d(0.0);
+    msg.add_d(1.0);
+    msg.add_d(std::numeric_limits<double>::min());
+    msg.add_d(std::numeric_limits<double>::max());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_double/testcase.proto b/third_party/protozero/test/t/repeated_packed_double/testcase.proto
new file mode 100644
index 00000000000..ccb5b241277
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_double/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedDouble;
+
+message Test {
+
+    repeated double d = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_enum/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_enum/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_enum/data-many.pbf b/third_party/protozero/test/t/repeated_packed_enum/data-many.pbf
new file mode 100644
index 00000000000..c0226e9dc48
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_enum/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_enum/data-one.pbf b/third_party/protozero/test/t/repeated_packed_enum/data-one.pbf
new file mode 100644
index 00000000000..742c749a92b
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_enum/data-one.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_enum/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_enum/reader_test_cases.cpp
new file mode 100644
index 00000000000..248474c0c10
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_enum/reader_test_cases.cpp
@@ -0,0 +1,78 @@
+
+#include <test.hpp>
+
+TEST_CASE("read repeated packed enum field: empty") {
+    const std::string buffer = load_data("repeated_packed_enum/data-empty");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read repeated packed enum field: one") {
+    const std::string buffer = load_data("repeated_packed_enum/data-one");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    const auto it_range = item.get_packed_enum();
+    REQUIRE_FALSE(item.next());
+
+    REQUIRE(it_range.begin() != it_range.end());
+    REQUIRE(*it_range.begin() == 0 /* BLACK */);
+    REQUIRE(std::next(it_range.begin()) == it_range.end());
+}
+
+TEST_CASE("read repeated packed enum field: many") {
+    const std::string buffer = load_data("repeated_packed_enum/data-many");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    const auto it_range = item.get_packed_enum();
+    REQUIRE_FALSE(item.next());
+
+    auto it = it_range.begin();
+    REQUIRE(it != it_range.end());
+    REQUIRE(*it++ == 0 /* BLACK */);
+    REQUIRE(*it++ == 3 /* BLUE */);
+    REQUIRE(*it++ == 2 /* GREEN */);
+    REQUIRE(it == it_range.end());
+}
+
+TEST_CASE("read repeated packed enum field: end of buffer") {
+    const std::string buffer = load_data("repeated_packed_enum/data-many");
+
+    for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+        protozero::pbf_reader item{buffer.data(), i};
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.get_packed_enum(), const protozero::end_of_buffer_exception&);
+    }
+}
+
+TEST_CASE("write repeated packed enum field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty") {
+        const int32_t data[] = { 0 /* BLACK */ };
+        pw.add_packed_enum(1, std::begin(data), std::begin(data) /* !!!! */);
+
+        REQUIRE(buffer == load_data("repeated_packed_enum/data-empty"));
+    }
+
+    SECTION("one") {
+        const int32_t data[] = { 0 /* BLACK */ };
+        pw.add_packed_enum(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_enum/data-one"));
+    }
+
+    SECTION("many") {
+        const int32_t data[] = { 0 /* BLACK */, 3 /* BLUE */, 2 /* GREEN */ };
+        pw.add_packed_enum(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_enum/data-many"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_enum/testcase.cpp b/third_party/protozero/test/t/repeated_packed_enum/testcase.cpp
new file mode 100644
index 00000000000..299995303f1
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_enum/testcase.cpp
@@ -0,0 +1,17 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedEnum::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_color(TestRepeatedPackedEnum::BLACK);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_color(TestRepeatedPackedEnum::BLUE);
+    msg.add_color(TestRepeatedPackedEnum::GREEN);
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_enum/testcase.proto b/third_party/protozero/test/t/repeated_packed_enum/testcase.proto
new file mode 100644
index 00000000000..01e5df3724b
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_enum/testcase.proto
@@ -0,0 +1,18 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedEnum;
+
+enum Color {
+    BLACK = 0;
+    RED   = 1;
+    GREEN = 2;
+    BLUE  = 3;
+}
+
+message Test {
+
+    repeated Color color = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_fixed32/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_fixed32/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_fixed32/data-many.pbf b/third_party/protozero/test/t/repeated_packed_fixed32/data-many.pbf
new file mode 100644
index 00000000000..eff5226b93b
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_fixed32/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_fixed32/data-one.pbf b/third_party/protozero/test/t/repeated_packed_fixed32/data-one.pbf
new file mode 100644
index 00000000000..43f147d2aac
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_fixed32/data-one.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_fixed32/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_fixed32/reader_test_cases.cpp
new file mode 100644
index 00000000000..fc2a179d1f5
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_fixed32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE fixed32
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint32_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_fixed32/repeated_packed_fixed32_testcase.proto b/third_party/protozero/test/t/repeated_packed_fixed32/repeated_packed_fixed32_testcase.proto
new file mode 100644
index 00000000000..64f258ef774
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_fixed32/repeated_packed_fixed32_testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedFixed32;
+
+message Test {
+
+    repeated fixed32 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_fixed32/testcase.cpp b/third_party/protozero/test/t/repeated_packed_fixed32/testcase.cpp
new file mode 100644
index 00000000000..901e6ad23d0
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_fixed32/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedFixed32::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17UL);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200UL);
+    msg.add_i(0UL);
+    msg.add_i(1UL);
+    msg.add_i(std::numeric_limits<uint32_t>::max());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_fixed32/writer_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_fixed32/writer_test_cases.cpp
new file mode 100644
index 00000000000..e8b98a6e804
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_fixed32/writer_test_cases.cpp
@@ -0,0 +1,74 @@
+
+#include <test.hpp>
+
+#include "t/repeated_packed_fixed32/repeated_packed_fixed32_testcase.pb.h"
+
+TEST_CASE("write repeated packed fixed32 field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestRepeatedPackedFixed32::Test msg;
+
+    SECTION("empty") {
+        uint32_t data[] = { 17UL };
+        pw.add_packed_fixed32(1, std::begin(data), std::begin(data) /* !!!! */);
+    }
+
+    SECTION("one") {
+        uint32_t data[] = { 17UL };
+        pw.add_packed_fixed32(1, std::begin(data), std::end(data));
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i().size() == 1);
+        REQUIRE(msg.i(0) == 17UL);
+    }
+
+    SECTION("many") {
+        uint32_t data[] = { 17UL, 0UL, 1UL, std::numeric_limits<uint32_t>::max() };
+        pw.add_packed_fixed32(1, std::begin(data), std::end(data));
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.i().size() == 4);
+        REQUIRE(msg.i(0) == 17UL);
+        REQUIRE(msg.i(1) ==  0UL);
+        REQUIRE(msg.i(2) ==  1UL);
+        REQUIRE(msg.i(3) == std::numeric_limits<uint32_t>::max());
+    }
+}
+
+TEST_CASE("write from different types of iterators and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestRepeatedPackedFixed32::Test msg;
+
+    SECTION("from uint16_t") {
+        uint16_t data[] = { 1, 4, 9, 16, 25 };
+
+        pw.add_packed_fixed32(1, std::begin(data), std::end(data));
+    }
+
+    SECTION("from string") {
+        std::string data = "1 4 9 16 25";
+        std::stringstream sdata(data);
+
+        std::istream_iterator<uint32_t> eod;
+        std::istream_iterator<uint32_t> it(sdata);
+
+        pw.add_packed_fixed32(1, it, eod);
+    }
+
+    msg.ParseFromString(buffer);
+
+    REQUIRE(msg.i().size() == 5);
+    REQUIRE(msg.i(0) ==  1);
+    REQUIRE(msg.i(1) ==  4);
+    REQUIRE(msg.i(2) ==  9);
+    REQUIRE(msg.i(3) == 16);
+    REQUIRE(msg.i(4) == 25);
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_fixed64/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_fixed64/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_fixed64/data-many.pbf b/third_party/protozero/test/t/repeated_packed_fixed64/data-many.pbf
new file mode 100644
index 00000000000..c007cb93813
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_fixed64/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_fixed64/data-one.pbf b/third_party/protozero/test/t/repeated_packed_fixed64/data-one.pbf
new file mode 100644
index 00000000000..e45639d0904
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_fixed64/data-one.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_fixed64/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_fixed64/reader_test_cases.cpp
new file mode 100644
index 00000000000..4959fe6f365
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_fixed64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE fixed64
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint64_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_fixed64/testcase.cpp b/third_party/protozero/test/t/repeated_packed_fixed64/testcase.cpp
new file mode 100644
index 00000000000..49e9e39f5d0
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_fixed64/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedFixed64::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17ULL);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200UL);
+    msg.add_i(0ULL);
+    msg.add_i(1ULL);
+    msg.add_i(std::numeric_limits<uint64_t>::max());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_fixed64/testcase.proto b/third_party/protozero/test/t/repeated_packed_fixed64/testcase.proto
new file mode 100644
index 00000000000..13a954b41ce
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_fixed64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedFixed64;
+
+message Test {
+
+    repeated fixed64 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_float/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_float/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_float/data-many.pbf b/third_party/protozero/test/t/repeated_packed_float/data-many.pbf
new file mode 100644
index 00000000000..1f685d47883
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_float/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_float/data-one.pbf b/third_party/protozero/test/t/repeated_packed_float/data-one.pbf
new file mode 100644
index 00000000000..cd8139b5258
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_float/data-one.pbf
@@ -0,0 +1,2 @@
+
+R��A
\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_float/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_float/reader_test_cases.cpp
new file mode 100644
index 00000000000..97eef2e6b0a
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_float/reader_test_cases.cpp
@@ -0,0 +1,89 @@
+
+#include <test.hpp>
+
+TEST_CASE("read repeated packed float field") {
+    // Run these tests twice, the second time we basically move the data
+    // one byte down in the buffer. It doesn't matter how the data or buffer
+    // is aligned before that, in at least one of these cases the floats will
+    // not be aligned properly. So we test that even in that case the floats
+    // will be extracted properly.
+
+    for (std::string::size_type n = 0; n < 2; ++n) {
+        std::string abuffer;
+        abuffer.reserve(1000);
+        abuffer.append(n, '\0');
+
+        SECTION("empty") {
+            abuffer.append(load_data("repeated_packed_float/data-empty"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE_FALSE(item.next());
+        }
+
+        SECTION("one") {
+            abuffer.append(load_data("repeated_packed_float/data-one"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            auto it_range = item.get_packed_float();
+            REQUIRE_FALSE(item.next());
+
+            REQUIRE(*it_range.begin() == Approx(17.34f));
+            REQUIRE(std::next(it_range.begin()) == it_range.end());
+        }
+
+        SECTION("many") {
+            abuffer.append(load_data("repeated_packed_float/data-many"));
+            protozero::pbf_reader item{abuffer.data() + n, abuffer.size() - n};
+
+            REQUIRE(item.next());
+            auto it_range = item.get_packed_float();
+            REQUIRE_FALSE(item.next());
+
+            auto it = it_range.begin();
+            REQUIRE(*it++ == Approx(17.34f));
+            REQUIRE(*it++ == Approx( 0.0f));
+            REQUIRE(*it++ == Approx( 1.0f));
+            REQUIRE(*it++ == std::numeric_limits<float>::min());
+            REQUIRE(*it++ == std::numeric_limits<float>::max());
+            REQUIRE(it == it_range.end());
+        }
+
+        SECTION("end_of_buffer") {
+            abuffer.append(load_data("repeated_packed_float/data-many"));
+
+            for (std::string::size_type i = 1; i < abuffer.size() - n; ++i) {
+                protozero::pbf_reader item{abuffer.data() + n, i};
+                REQUIRE(item.next());
+                REQUIRE_THROWS_AS(item.get_packed_float(), const protozero::end_of_buffer_exception&);
+            }
+        }
+    }
+}
+
+TEST_CASE("write repeated packed float field") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("empty") {
+        float data[] = { 17.34f };
+        pw.add_packed_float(1, std::begin(data), std::begin(data) /* !!!! */);
+
+        REQUIRE(buffer == load_data("repeated_packed_float/data-empty"));
+    }
+
+    SECTION("one") {
+        float data[] = { 17.34f };
+        pw.add_packed_float(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_float/data-one"));
+    }
+
+    SECTION("many") {
+        float data[] = { 17.34f, 0.0f, 1.0f, std::numeric_limits<float>::min(), std::numeric_limits<float>::max() };
+        pw.add_packed_float(1, std::begin(data), std::end(data));
+
+        REQUIRE(buffer == load_data("repeated_packed_float/data-many"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_float/testcase.cpp b/third_party/protozero/test/t/repeated_packed_float/testcase.cpp
new file mode 100644
index 00000000000..6498a704c30
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_float/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedFloat::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_f(17.34f);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_f(0.0f);
+    msg.add_f(1.0f);
+    msg.add_f(std::numeric_limits<float>::min());
+    msg.add_f(std::numeric_limits<float>::max());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_float/testcase.proto b/third_party/protozero/test/t/repeated_packed_float/testcase.proto
new file mode 100644
index 00000000000..1e85ab04c80
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_float/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedFloat;
+
+message Test {
+
+    repeated float f = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_int32/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_int32/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_int32/data-many.pbf b/third_party/protozero/test/t/repeated_packed_int32/data-many.pbf
new file mode 100644
index 00000000000..fe5336a2614
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_int32/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_int32/data-one.pbf b/third_party/protozero/test/t/repeated_packed_int32/data-one.pbf
new file mode 100644
index 00000000000..7f9c1a63238
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int32/data-one.pbf
@@ -0,0 +1,2 @@
+
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_int32/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_int32/reader_test_cases.cpp
new file mode 100644
index 00000000000..206c61c2391
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE int32
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int32_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_int32/testcase.cpp b/third_party/protozero/test/t/repeated_packed_int32/testcase.cpp
new file mode 100644
index 00000000000..ab9c5f70b11
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int32/testcase.cpp
@@ -0,0 +1,22 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedInt32::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17L);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200);
+    msg.add_i(0L);
+    msg.add_i(1L);
+    msg.add_i(std::numeric_limits<int32_t>::max());
+    msg.add_i(-200);
+    msg.add_i(-1L);
+    msg.add_i(std::numeric_limits<int32_t>::min());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_int32/testcase.proto b/third_party/protozero/test/t/repeated_packed_int32/testcase.proto
new file mode 100644
index 00000000000..beeceedd98e
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int32/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedInt32;
+
+message Test {
+
+    repeated int32 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_int64/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_int64/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_int64/data-many.pbf b/third_party/protozero/test/t/repeated_packed_int64/data-many.pbf
new file mode 100644
index 00000000000..0f719213e82
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_int64/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_int64/data-one.pbf b/third_party/protozero/test/t/repeated_packed_int64/data-one.pbf
new file mode 100644
index 00000000000..7f9c1a63238
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int64/data-one.pbf
@@ -0,0 +1,2 @@
+
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_int64/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_int64/reader_test_cases.cpp
new file mode 100644
index 00000000000..d5c2beb0e99
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE int64
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int64_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_int64/testcase.cpp b/third_party/protozero/test/t/repeated_packed_int64/testcase.cpp
new file mode 100644
index 00000000000..eb4002ed1e7
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int64/testcase.cpp
@@ -0,0 +1,22 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedInt64::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17LL);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200);
+    msg.add_i(0LL);
+    msg.add_i(1LL);
+    msg.add_i(std::numeric_limits<int64_t>::max());
+    msg.add_i(-200);
+    msg.add_i(-1LL);
+    msg.add_i(std::numeric_limits<int64_t>::min());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_int64/testcase.proto b/third_party/protozero/test/t/repeated_packed_int64/testcase.proto
new file mode 100644
index 00000000000..73102c67fcf
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_int64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedInt64;
+
+message Test {
+
+    repeated int64 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed32/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_sfixed32/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed32/data-many.pbf b/third_party/protozero/test/t/repeated_packed_sfixed32/data-many.pbf
new file mode 100644
index 00000000000..e6922e69199
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_sfixed32/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed32/data-one.pbf b/third_party/protozero/test/t/repeated_packed_sfixed32/data-one.pbf
new file mode 100644
index 00000000000..43f147d2aac
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_sfixed32/data-one.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed32/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_sfixed32/reader_test_cases.cpp
new file mode 100644
index 00000000000..eb308f74176
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sfixed32/reader_test_cases.cpp
@@ -0,0 +1,30 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sfixed32
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int32_t;
+
+#include <packed_access.hpp>
+
+TEST_CASE("length value must be dividable by sizeof(T)") {
+    std::string data{load_data("repeated_packed_sfixed32/data-many")};
+
+    SECTION("1") {
+        data[1] = 1;
+    }
+
+    SECTION("2") {
+        data[1] = 2;
+    }
+
+    SECTION("3") {
+        data[1] = 3;
+    }
+
+    protozero::pbf_reader item{data};
+
+    REQUIRE(item.next());
+    REQUIRE_THROWS_AS(item.get_packed_sfixed32(), const protozero::invalid_length_exception&);
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed32/testcase.cpp b/third_party/protozero/test/t/repeated_packed_sfixed32/testcase.cpp
new file mode 100644
index 00000000000..1a84cf57fc6
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sfixed32/testcase.cpp
@@ -0,0 +1,22 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedSFixed32::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200);
+    msg.add_i(0);
+    msg.add_i(1);
+    msg.add_i(std::numeric_limits<int32_t>::max());
+    msg.add_i(-200);
+    msg.add_i(-1);
+    msg.add_i(std::numeric_limits<int32_t>::min());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed32/testcase.proto b/third_party/protozero/test/t/repeated_packed_sfixed32/testcase.proto
new file mode 100644
index 00000000000..c49c61cc187
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sfixed32/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedSFixed32;
+
+message Test {
+
+    repeated sfixed32 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed64/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_sfixed64/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed64/data-many.pbf b/third_party/protozero/test/t/repeated_packed_sfixed64/data-many.pbf
new file mode 100644
index 00000000000..5539d4ff4a6
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_sfixed64/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed64/data-one.pbf b/third_party/protozero/test/t/repeated_packed_sfixed64/data-one.pbf
new file mode 100644
index 00000000000..e45639d0904
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_sfixed64/data-one.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed64/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_sfixed64/reader_test_cases.cpp
new file mode 100644
index 00000000000..35979383891
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sfixed64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sfixed64
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int64_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed64/testcase.cpp b/third_party/protozero/test/t/repeated_packed_sfixed64/testcase.cpp
new file mode 100644
index 00000000000..673a5ea5a6d
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sfixed64/testcase.cpp
@@ -0,0 +1,22 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedSFixed64::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200);
+    msg.add_i(0);
+    msg.add_i(1);
+    msg.add_i(std::numeric_limits<int64_t>::max());
+    msg.add_i(-200);
+    msg.add_i(-1);
+    msg.add_i(std::numeric_limits<int64_t>::min());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sfixed64/testcase.proto b/third_party/protozero/test/t/repeated_packed_sfixed64/testcase.proto
new file mode 100644
index 00000000000..fdd6538b65c
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sfixed64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedSFixed64;
+
+message Test {
+
+    repeated sfixed64 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sint32/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_sint32/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_sint32/data-many.pbf b/third_party/protozero/test/t/repeated_packed_sint32/data-many.pbf
new file mode 100644
index 00000000000..e65bbd915b1
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_sint32/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_sint32/data-one.pbf b/third_party/protozero/test/t/repeated_packed_sint32/data-one.pbf
new file mode 100644
index 00000000000..3c51bf94892
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint32/data-one.pbf
@@ -0,0 +1,2 @@
+
+
"
\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_sint32/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_sint32/reader_test_cases.cpp
new file mode 100644
index 00000000000..4c6a2d81f59
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sint32
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int32_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_sint32/testcase.cpp b/third_party/protozero/test/t/repeated_packed_sint32/testcase.cpp
new file mode 100644
index 00000000000..8145e4fde64
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint32/testcase.cpp
@@ -0,0 +1,22 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedSInt32::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17L);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200);
+    msg.add_i(0L);
+    msg.add_i(1L);
+    msg.add_i(std::numeric_limits<int32_t>::max());
+    msg.add_i(-200);
+    msg.add_i(-1L);
+    msg.add_i(std::numeric_limits<int32_t>::min());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sint32/testcase.proto b/third_party/protozero/test/t/repeated_packed_sint32/testcase.proto
new file mode 100644
index 00000000000..e1f48f7fbb8
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint32/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedSInt32;
+
+message Test {
+
+    repeated sint32 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sint64/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_sint64/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_sint64/data-many.pbf b/third_party/protozero/test/t/repeated_packed_sint64/data-many.pbf
new file mode 100644
index 00000000000..89df69a8e5b
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_sint64/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_sint64/data-one.pbf b/third_party/protozero/test/t/repeated_packed_sint64/data-one.pbf
new file mode 100644
index 00000000000..3c51bf94892
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint64/data-one.pbf
@@ -0,0 +1,2 @@
+
+
"
\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_sint64/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_sint64/reader_test_cases.cpp
new file mode 100644
index 00000000000..1a3fb27ea10
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sint64
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int64_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_sint64/testcase.cpp b/third_party/protozero/test/t/repeated_packed_sint64/testcase.cpp
new file mode 100644
index 00000000000..920c3be7015
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint64/testcase.cpp
@@ -0,0 +1,22 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedSInt64::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17LL);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200);
+    msg.add_i(0LL);
+    msg.add_i(1LL);
+    msg.add_i(std::numeric_limits<int64_t>::max());
+    msg.add_i(-200);
+    msg.add_i(-1LL);
+    msg.add_i(std::numeric_limits<int64_t>::min());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_sint64/testcase.proto b/third_party/protozero/test/t/repeated_packed_sint64/testcase.proto
new file mode 100644
index 00000000000..160074f711a
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_sint64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedSInt64;
+
+message Test {
+
+    repeated sint64 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_uint32/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_uint32/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_uint32/data-many.pbf b/third_party/protozero/test/t/repeated_packed_uint32/data-many.pbf
new file mode 100644
index 00000000000..c58a7e5ccb7
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_uint32/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_uint32/data-one.pbf b/third_party/protozero/test/t/repeated_packed_uint32/data-one.pbf
new file mode 100644
index 00000000000..7f9c1a63238
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint32/data-one.pbf
@@ -0,0 +1,2 @@
+
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_uint32/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_uint32/reader_test_cases.cpp
new file mode 100644
index 00000000000..d68cabaa677
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE uint32
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint32_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_uint32/testcase.cpp b/third_party/protozero/test/t/repeated_packed_uint32/testcase.cpp
new file mode 100644
index 00000000000..ec21b635b00
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint32/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedUInt32::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17UL);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200UL);
+    msg.add_i(0UL);
+    msg.add_i(1UL);
+    msg.add_i(std::numeric_limits<uint32_t>::max());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_uint32/testcase.proto b/third_party/protozero/test/t/repeated_packed_uint32/testcase.proto
new file mode 100644
index 00000000000..8d1647b9473
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint32/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedUInt32;
+
+message Test {
+
+    repeated uint32 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_uint64/data-empty.pbf b/third_party/protozero/test/t/repeated_packed_uint64/data-empty.pbf
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/third_party/protozero/test/t/repeated_packed_uint64/data-many.pbf b/third_party/protozero/test/t/repeated_packed_uint64/data-many.pbf
new file mode 100644
index 00000000000..0e1dcc8d81f
Binary files /dev/null and b/third_party/protozero/test/t/repeated_packed_uint64/data-many.pbf differ
diff --git a/third_party/protozero/test/t/repeated_packed_uint64/data-one.pbf b/third_party/protozero/test/t/repeated_packed_uint64/data-one.pbf
new file mode 100644
index 00000000000..7f9c1a63238
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint64/data-one.pbf
@@ -0,0 +1,2 @@
+
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/repeated_packed_uint64/reader_test_cases.cpp b/third_party/protozero/test/t/repeated_packed_uint64/reader_test_cases.cpp
new file mode 100644
index 00000000000..7f2e95a605c
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE uint64
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint64_t;
+
+#include <packed_access.hpp>
+
diff --git a/third_party/protozero/test/t/repeated_packed_uint64/testcase.cpp b/third_party/protozero/test/t/repeated_packed_uint64/testcase.cpp
new file mode 100644
index 00000000000..d77795bfe95
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint64/testcase.cpp
@@ -0,0 +1,19 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestRepeatedPackedUInt64::Test msg;
+
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.add_i(17ULL);
+    write_to_file(msg, "data-one.pbf");
+
+    msg.add_i(200UL);
+    msg.add_i(0ULL);
+    msg.add_i(1ULL);
+    msg.add_i(std::numeric_limits<uint64_t>::max());
+    write_to_file(msg, "data-many.pbf");
+}
+
diff --git a/third_party/protozero/test/t/repeated_packed_uint64/testcase.proto b/third_party/protozero/test/t/repeated_packed_uint64/testcase.proto
new file mode 100644
index 00000000000..fbbc57a5073
--- /dev/null
+++ b/third_party/protozero/test/t/repeated_packed_uint64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestRepeatedPackedUInt64;
+
+message Test {
+
+    repeated uint64 i = 1 [packed=true];
+
+}
+
diff --git a/third_party/protozero/test/t/rollback/reader_test_cases.cpp b/third_party/protozero/test/t/rollback/reader_test_cases.cpp
new file mode 100644
index 00000000000..fa4c77f216e
--- /dev/null
+++ b/third_party/protozero/test/t/rollback/reader_test_cases.cpp
@@ -0,0 +1,204 @@
+
+#include <test.hpp>
+
+TEST_CASE("rollback when using packed_field functions") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    pw.add_fixed64(2, 111);
+    pw.add_string(3, "foo");
+
+    SECTION("empty - should do rollback") {
+        {
+            protozero::packed_field_sint64 field{pw, 1};
+        }
+
+        pw.add_int32(4, 123);
+
+        protozero::pbf_reader msg{buffer};
+
+        msg.next();
+        REQUIRE(msg.tag() == 2);
+        REQUIRE(msg.get_fixed64() == 111);
+
+        msg.next();
+        REQUIRE(msg.tag() == 3);
+        REQUIRE(msg.get_string() == "foo");
+
+        msg.next();
+        REQUIRE(msg.tag() == 4);
+        REQUIRE(msg.get_int32() == 123);
+    }
+
+    SECTION("one") {
+        {
+            protozero::packed_field_sint64 field{pw, 1};
+            field.add_element(17L);
+        }
+
+        pw.add_int32(4, 123);
+
+        protozero::pbf_reader msg{buffer};
+
+        msg.next();
+        REQUIRE(msg.tag() == 2);
+        REQUIRE(msg.get_fixed64() == 111);
+
+        msg.next();
+        REQUIRE(msg.tag() == 3);
+        REQUIRE(msg.get_string() == "foo");
+
+        msg.next();
+        REQUIRE(msg.tag() == 1);
+        const auto it_range = msg.get_packed_sint64();
+        auto it = it_range.begin();
+        REQUIRE(*it++ == 17L);
+        REQUIRE(it == it_range.end());
+
+        msg.next();
+        REQUIRE(msg.tag() == 4);
+        REQUIRE(msg.get_int32() == 123);
+    }
+
+    SECTION("many") {
+        {
+            protozero::packed_field_sint64 field{pw, 1};
+            field.add_element(17L);
+            field.add_element( 0L);
+            field.add_element( 1L);
+            field.add_element(-1L);
+            field.add_element(std::numeric_limits<int64_t>::max());
+            field.add_element(std::numeric_limits<int64_t>::min());
+        }
+
+        pw.add_int32(4, 123);
+
+        protozero::pbf_reader msg{buffer};
+
+        msg.next();
+        REQUIRE(msg.tag() == 2);
+        REQUIRE(msg.get_fixed64() == 111);
+
+        msg.next();
+        REQUIRE(msg.tag() == 3);
+        REQUIRE(msg.get_string() == "foo");
+
+        msg.next();
+        REQUIRE(msg.tag() == 1);
+        const auto it_range = msg.get_packed_sint64();
+        auto it = it_range.begin();
+        REQUIRE(*it++ == 17L);
+        REQUIRE(*it++ ==  0L);
+        REQUIRE(*it++ ==  1L);
+        REQUIRE(*it++ == -1L);
+        REQUIRE(*it++ == std::numeric_limits<int64_t>::max());
+        REQUIRE(*it++ == std::numeric_limits<int64_t>::min());
+        REQUIRE(it == it_range.end());
+
+        msg.next();
+        REQUIRE(msg.tag() == 4);
+        REQUIRE(msg.get_int32() == 123);
+    }
+
+    SECTION("manual rollback") {
+        {
+            protozero::packed_field_sint64 field{pw, 1};
+            field.add_element(17L);
+            field.add_element( 0L);
+            field.add_element( 1L);
+            field.rollback();
+        }
+
+        pw.add_int32(4, 123);
+
+        protozero::pbf_reader msg{buffer};
+
+        msg.next();
+        REQUIRE(msg.tag() == 2);
+        REQUIRE(msg.get_fixed64() == 111);
+
+        msg.next();
+        REQUIRE(msg.tag() == 3);
+        REQUIRE(msg.get_string() == "foo");
+
+        msg.next();
+        REQUIRE(msg.tag() == 4);
+        REQUIRE(msg.get_int32() == 123);
+    }
+
+    SECTION("manual rollback") {
+        {
+            protozero::packed_field_sint64 field{pw, 1};
+            field.add_element(1L);
+            field.rollback();
+            REQUIRE_THROWS_AS(field.add_element(1L), const assert_error&);
+        }
+    }
+}
+
+TEST_CASE("rollback when using submessages") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    pw.add_fixed64(2, 111);
+    pw.add_string(3, "foo");
+
+    {
+        protozero::pbf_writer pws{pw, 1};
+        pws.add_string(1, "foobar");
+        pws.rollback();
+    }
+
+    pw.add_int32(4, 123);
+
+    protozero::pbf_reader msg{buffer};
+
+    msg.next();
+    REQUIRE(msg.tag() == 2);
+    REQUIRE(msg.get_fixed64() == 111);
+
+    msg.next();
+    REQUIRE(msg.tag() == 3);
+    REQUIRE(msg.get_string() == "foo");
+
+    msg.next();
+    REQUIRE(msg.tag() == 4);
+    REQUIRE(msg.get_int32() == 123);
+
+}
+
+TEST_CASE("rollback on parent message is never allowed") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+    REQUIRE_THROWS_AS(pw.rollback(), const assert_error&);
+}
+
+TEST_CASE("rollback on parent message is not allowed even if there is a submessage") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    pw.add_fixed64(2, 111);
+    pw.add_string(3, "foo");
+
+    {
+        protozero::pbf_writer pws{pw, 1};
+        pws.add_string(1, "foobar");
+        REQUIRE_THROWS_AS(pw.rollback(), const assert_error&);
+    }
+}
+
+TEST_CASE("rollback on message is not allowed if there is a nested submessage") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    pw.add_fixed64(2, 111);
+    pw.add_string(3, "foo");
+
+    {
+        protozero::pbf_writer pws{pw, 1};
+        pws.add_string(1, "foobar");
+        protozero::pbf_writer pws2{pws, 1};
+        REQUIRE_THROWS_AS(pws.rollback(), const assert_error&);
+    }
+}
+
diff --git a/third_party/protozero/test/t/sfixed32/data-max.pbf b/third_party/protozero/test/t/sfixed32/data-max.pbf
new file mode 100644
index 00000000000..52fe7ac2ea6
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed32/data-max.pbf
@@ -0,0 +1 @@
+
���
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sfixed32/data-min.pbf b/third_party/protozero/test/t/sfixed32/data-min.pbf
new file mode 100644
index 00000000000..2c570d4217f
Binary files /dev/null and b/third_party/protozero/test/t/sfixed32/data-min.pbf differ
diff --git a/third_party/protozero/test/t/sfixed32/data-neg.pbf b/third_party/protozero/test/t/sfixed32/data-neg.pbf
new file mode 100644
index 00000000000..416d363184c
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed32/data-neg.pbf
@@ -0,0 +1 @@
+
����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sfixed32/data-neg200.pbf b/third_party/protozero/test/t/sfixed32/data-neg200.pbf
new file mode 100644
index 00000000000..19d26f1ea63
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed32/data-neg200.pbf
@@ -0,0 +1 @@
+
8���
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sfixed32/data-pos.pbf b/third_party/protozero/test/t/sfixed32/data-pos.pbf
new file mode 100644
index 00000000000..e63fa08fa0c
Binary files /dev/null and b/third_party/protozero/test/t/sfixed32/data-pos.pbf differ
diff --git a/third_party/protozero/test/t/sfixed32/data-pos200.pbf b/third_party/protozero/test/t/sfixed32/data-pos200.pbf
new file mode 100644
index 00000000000..7dc726eab20
Binary files /dev/null and b/third_party/protozero/test/t/sfixed32/data-pos200.pbf differ
diff --git a/third_party/protozero/test/t/sfixed32/data-zero.pbf b/third_party/protozero/test/t/sfixed32/data-zero.pbf
new file mode 100644
index 00000000000..1cf2c40c87e
Binary files /dev/null and b/third_party/protozero/test/t/sfixed32/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/sfixed32/reader_test_cases.cpp b/third_party/protozero/test/t/sfixed32/reader_test_cases.cpp
new file mode 100644
index 00000000000..8dadcaad6fc
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sfixed32
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int32_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/sfixed32/testcase.cpp b/third_party/protozero/test/t/sfixed32/testcase.cpp
new file mode 100644
index 00000000000..e9f21ce49b7
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed32/testcase.cpp
@@ -0,0 +1,29 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestSFixed32::Test msg;
+
+    msg.set_i(0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(-1);
+    write_to_file(msg, "data-neg.pbf");
+
+    msg.set_i(-200);
+    write_to_file(msg, "data-neg200.pbf");
+
+    msg.set_i(std::numeric_limits<int32_t>::max());
+    write_to_file(msg, "data-max.pbf");
+
+    msg.set_i(std::numeric_limits<int32_t>::min());
+    write_to_file(msg, "data-min.pbf");
+}
+
diff --git a/third_party/protozero/test/t/sfixed32/testcase.proto b/third_party/protozero/test/t/sfixed32/testcase.proto
new file mode 100644
index 00000000000..c2cb3f12655
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed32/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestSFixed32;
+
+message Test {
+
+    required sfixed32 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/sfixed64/data-max.pbf b/third_party/protozero/test/t/sfixed64/data-max.pbf
new file mode 100644
index 00000000000..7ec5cacfc13
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed64/data-max.pbf
@@ -0,0 +1 @@
+	�������
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sfixed64/data-min.pbf b/third_party/protozero/test/t/sfixed64/data-min.pbf
new file mode 100644
index 00000000000..827eb054162
Binary files /dev/null and b/third_party/protozero/test/t/sfixed64/data-min.pbf differ
diff --git a/third_party/protozero/test/t/sfixed64/data-neg.pbf b/third_party/protozero/test/t/sfixed64/data-neg.pbf
new file mode 100644
index 00000000000..cb810a5f484
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed64/data-neg.pbf
@@ -0,0 +1 @@
+	��������
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sfixed64/data-neg200.pbf b/third_party/protozero/test/t/sfixed64/data-neg200.pbf
new file mode 100644
index 00000000000..64602252f57
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed64/data-neg200.pbf
@@ -0,0 +1 @@
+	8�������
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sfixed64/data-pos.pbf b/third_party/protozero/test/t/sfixed64/data-pos.pbf
new file mode 100644
index 00000000000..83f1583695d
Binary files /dev/null and b/third_party/protozero/test/t/sfixed64/data-pos.pbf differ
diff --git a/third_party/protozero/test/t/sfixed64/data-pos200.pbf b/third_party/protozero/test/t/sfixed64/data-pos200.pbf
new file mode 100644
index 00000000000..be400ca7f37
Binary files /dev/null and b/third_party/protozero/test/t/sfixed64/data-pos200.pbf differ
diff --git a/third_party/protozero/test/t/sfixed64/data-zero.pbf b/third_party/protozero/test/t/sfixed64/data-zero.pbf
new file mode 100644
index 00000000000..5f47e98c6bb
Binary files /dev/null and b/third_party/protozero/test/t/sfixed64/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/sfixed64/reader_test_cases.cpp b/third_party/protozero/test/t/sfixed64/reader_test_cases.cpp
new file mode 100644
index 00000000000..6e63e5b1aaa
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sfixed64
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int64_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/sfixed64/testcase.cpp b/third_party/protozero/test/t/sfixed64/testcase.cpp
new file mode 100644
index 00000000000..aca309356e0
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed64/testcase.cpp
@@ -0,0 +1,29 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestSFixed64::Test msg;
+
+    msg.set_i(0);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(-1);
+    write_to_file(msg, "data-neg.pbf");
+
+    msg.set_i(-200);
+    write_to_file(msg, "data-neg200.pbf");
+
+    msg.set_i(std::numeric_limits<int64_t>::max());
+    write_to_file(msg, "data-max.pbf");
+
+    msg.set_i(std::numeric_limits<int64_t>::min());
+    write_to_file(msg, "data-min.pbf");
+}
+
diff --git a/third_party/protozero/test/t/sfixed64/testcase.proto b/third_party/protozero/test/t/sfixed64/testcase.proto
new file mode 100644
index 00000000000..2c5875364c0
--- /dev/null
+++ b/third_party/protozero/test/t/sfixed64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestSFixed64;
+
+message Test {
+
+    required sfixed64 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/sint32/data-max.pbf b/third_party/protozero/test/t/sint32/data-max.pbf
new file mode 100644
index 00000000000..dfd6e7f8c0e
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/data-max.pbf
@@ -0,0 +1 @@
+����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint32/data-min.pbf b/third_party/protozero/test/t/sint32/data-min.pbf
new file mode 100644
index 00000000000..909ea9ad3ec
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/data-min.pbf
@@ -0,0 +1 @@
+����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint32/data-neg.pbf b/third_party/protozero/test/t/sint32/data-neg.pbf
new file mode 100644
index 00000000000..e19a122a540
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/data-neg.pbf
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint32/data-neg200.pbf b/third_party/protozero/test/t/sint32/data-neg200.pbf
new file mode 100644
index 00000000000..c1add161b05
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/data-neg200.pbf
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint32/data-pos.pbf b/third_party/protozero/test/t/sint32/data-pos.pbf
new file mode 100644
index 00000000000..009a24fee40
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/data-pos.pbf
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint32/data-pos200.pbf b/third_party/protozero/test/t/sint32/data-pos200.pbf
new file mode 100644
index 00000000000..2d26c9ac159
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/data-pos200.pbf
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint32/data-zero.pbf b/third_party/protozero/test/t/sint32/data-zero.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/sint32/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/sint32/reader_test_cases.cpp b/third_party/protozero/test/t/sint32/reader_test_cases.cpp
new file mode 100644
index 00000000000..4a0d4fae9ff
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sint32
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int32_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/sint32/testcase.cpp b/third_party/protozero/test/t/sint32/testcase.cpp
new file mode 100644
index 00000000000..88f491163d8
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/testcase.cpp
@@ -0,0 +1,29 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestSInt32::Test msg;
+
+    msg.set_i(0L);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1L);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(-1);
+    write_to_file(msg, "data-neg.pbf");
+
+    msg.set_i(-200);
+    write_to_file(msg, "data-neg200.pbf");
+
+    msg.set_i(std::numeric_limits<int32_t>::max());
+    write_to_file(msg, "data-max.pbf");
+
+    msg.set_i(std::numeric_limits<int32_t>::min());
+    write_to_file(msg, "data-min.pbf");
+}
+
diff --git a/third_party/protozero/test/t/sint32/testcase.proto b/third_party/protozero/test/t/sint32/testcase.proto
new file mode 100644
index 00000000000..d5f1ab915f5
--- /dev/null
+++ b/third_party/protozero/test/t/sint32/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestSInt32;
+
+message Test {
+
+    required sint32 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/sint64/data-max.pbf b/third_party/protozero/test/t/sint64/data-max.pbf
new file mode 100644
index 00000000000..7b5774254c8
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/data-max.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint64/data-min.pbf b/third_party/protozero/test/t/sint64/data-min.pbf
new file mode 100644
index 00000000000..1c2f041a6bc
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/data-min.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint64/data-neg.pbf b/third_party/protozero/test/t/sint64/data-neg.pbf
new file mode 100644
index 00000000000..e19a122a540
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/data-neg.pbf
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint64/data-neg200.pbf b/third_party/protozero/test/t/sint64/data-neg200.pbf
new file mode 100644
index 00000000000..c1add161b05
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/data-neg200.pbf
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint64/data-pos.pbf b/third_party/protozero/test/t/sint64/data-pos.pbf
new file mode 100644
index 00000000000..009a24fee40
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/data-pos.pbf
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint64/data-pos200.pbf b/third_party/protozero/test/t/sint64/data-pos200.pbf
new file mode 100644
index 00000000000..2d26c9ac159
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/data-pos200.pbf
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/third_party/protozero/test/t/sint64/data-zero.pbf b/third_party/protozero/test/t/sint64/data-zero.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/sint64/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/sint64/reader_test_cases.cpp b/third_party/protozero/test/t/sint64/reader_test_cases.cpp
new file mode 100644
index 00000000000..850172f1f20
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE sint64
+#define PBF_TYPE_IS_SIGNED 1
+using cpp_type = int64_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/sint64/testcase.cpp b/third_party/protozero/test/t/sint64/testcase.cpp
new file mode 100644
index 00000000000..fea56c6b38e
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/testcase.cpp
@@ -0,0 +1,29 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestSInt64::Test msg;
+
+    msg.set_i(0LL);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1LL);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200LL);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(-1LL);
+    write_to_file(msg, "data-neg.pbf");
+
+    msg.set_i(-200LL);
+    write_to_file(msg, "data-neg200.pbf");
+
+    msg.set_i(std::numeric_limits<int64_t>::max());
+    write_to_file(msg, "data-max.pbf");
+
+    msg.set_i(std::numeric_limits<int64_t>::min());
+    write_to_file(msg, "data-min.pbf");
+}
+
diff --git a/third_party/protozero/test/t/sint64/testcase.proto b/third_party/protozero/test/t/sint64/testcase.proto
new file mode 100644
index 00000000000..bf3132472c2
--- /dev/null
+++ b/third_party/protozero/test/t/sint64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestSInt64;
+
+message Test {
+
+    required sint64 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/skip/reader_test_cases.cpp b/third_party/protozero/test/t/skip/reader_test_cases.cpp
new file mode 100644
index 00000000000..b6de3e8120d
--- /dev/null
+++ b/third_party/protozero/test/t/skip/reader_test_cases.cpp
@@ -0,0 +1,130 @@
+
+#include <test.hpp>
+
+TEST_CASE("skip() skips the right amount of bytes") {
+    // These are all the data files which contain exactly one field.
+    //
+    // Create this list with:
+    //   cd test/t
+    //   find . -name data\*pbf -not -empty | sed -e 's/^.\/\(.*\).pbf/"\1",/'
+    // and then remove everything manually that contains more than one
+    // field.
+    const std::vector<std::string> filenames = {
+        "bool/data-also-true",
+        "bool/data-false",
+        "bool/data-still-true",
+        "bool/data-true",
+        "bytes/data-binary",
+        "bytes/data-empty",
+        "bytes/data-one",
+        "bytes/data-string",
+        "double/data-neg",
+        "double/data-pos",
+        "double/data-zero",
+        "enum/data-black",
+        "enum/data-blue",
+        "fixed32/data-max",
+        "fixed32/data-pos",
+        "fixed32/data-zero",
+        "fixed64/data-max",
+        "fixed64/data-pos",
+        "fixed64/data-zero",
+        "float/data-neg",
+        "float/data-pos",
+        "float/data-zero",
+        "int32/data-max",
+        "int32/data-min",
+        "int32/data-neg",
+        "int32/data-pos",
+        "int32/data-zero",
+        "int64/data-max",
+        "int64/data-min",
+        "int64/data-neg",
+        "int64/data-pos",
+        "int64/data-zero",
+        "message/data-message",
+        "repeated/data-one",
+        "repeated_packed_fixed32/data-many",
+        "repeated_packed_fixed32/data-one",
+        "repeated_packed_fixed64/data-many",
+        "repeated_packed_fixed64/data-one",
+        "repeated_packed_int32/data-many",
+        "repeated_packed_int32/data-one",
+        "repeated_packed_int64/data-many",
+        "repeated_packed_int64/data-one",
+        "repeated_packed_sfixed32/data-many",
+        "repeated_packed_sfixed32/data-one",
+        "repeated_packed_sfixed64/data-many",
+        "repeated_packed_sfixed64/data-one",
+        "repeated_packed_sint32/data-many",
+        "repeated_packed_sint32/data-one",
+        "repeated_packed_sint64/data-many",
+        "repeated_packed_sint64/data-one",
+        "repeated_packed_uint32/data-many",
+        "repeated_packed_uint32/data-one",
+        "repeated_packed_uint64/data-many",
+        "repeated_packed_uint64/data-one",
+        "sfixed32/data-max",
+        "sfixed32/data-min",
+        "sfixed32/data-zero",
+        "sfixed64/data-max",
+        "sfixed64/data-min",
+        "sfixed64/data-zero",
+        "sint32/data-max",
+        "sint32/data-min",
+        "sint32/data-neg",
+        "sint32/data-pos",
+        "sint32/data-zero",
+        "sint64/data-max",
+        "sint64/data-min",
+        "sint64/data-neg",
+        "sint64/data-pos",
+        "sint64/data-zero",
+        "string/data-empty",
+        "string/data-one",
+        "string/data-string",
+        "tags/data-tag-1",
+        "tags/data-tag-200000",
+        "tags/data-tag-200",
+        "tags/data-tag-max",
+        "uint32/data-max",
+        "uint32/data-pos",
+        "uint32/data-zero",
+        "uint64/data-max",
+        "uint64/data-pos",
+        "uint64/data-zero",
+    };
+
+    for (const auto& filename : filenames) {
+        const std::string buffer = load_data(filename);
+
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE(item.next());
+        item.skip();
+        REQUIRE_FALSE(item);
+    }
+}
+
+TEST_CASE("exceptional cases") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+    pw.add_fixed32(1, 123);
+
+    SECTION("check that next() throws on unknown field type") {
+        buffer[0] += 1; // hack to create illegal field type
+
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE_THROWS_AS(item.next(), const protozero::unknown_pbf_wire_type_exception&);
+    }
+
+    SECTION("check that skip() throws on short buffer") {
+        buffer.resize(buffer.size() - 1); // "remove" last byte from buffer
+        protozero::pbf_reader item{buffer};
+
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.skip(), const protozero::end_of_buffer_exception&);
+    }
+}
+
diff --git a/third_party/protozero/test/t/string/data-empty.pbf b/third_party/protozero/test/t/string/data-empty.pbf
new file mode 100644
index 00000000000..59f144ee093
Binary files /dev/null and b/third_party/protozero/test/t/string/data-empty.pbf differ
diff --git a/third_party/protozero/test/t/string/data-one.pbf b/third_party/protozero/test/t/string/data-one.pbf
new file mode 100644
index 00000000000..2764cf5cdac
--- /dev/null
+++ b/third_party/protozero/test/t/string/data-one.pbf
@@ -0,0 +1,2 @@
+
+
x
\ No newline at end of file
diff --git a/third_party/protozero/test/t/string/data-string.pbf b/third_party/protozero/test/t/string/data-string.pbf
new file mode 100644
index 00000000000..d7369a75954
--- /dev/null
+++ b/third_party/protozero/test/t/string/data-string.pbf
@@ -0,0 +1,2 @@
+
+foobar
\ No newline at end of file
diff --git a/third_party/protozero/test/t/string/reader_test_cases.cpp b/third_party/protozero/test/t/string/reader_test_cases.cpp
new file mode 100644
index 00000000000..f80c4c0c9b8
--- /dev/null
+++ b/third_party/protozero/test/t/string/reader_test_cases.cpp
@@ -0,0 +1,106 @@
+
+#include <test.hpp>
+
+TEST_CASE("read string field using get_string: empty") {
+    const std::string buffer = load_data("string/data-empty");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_string().empty());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read string field using get_string: one") {
+    const std::string buffer = load_data("string/data-one");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_string() == "x");
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read string field using get_string: string") {
+    const std::string buffer = load_data("string/data-string");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.get_string() == "foobar");
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read string field using get_string: end of buffer") {
+    const std::string buffer = load_data("string/data-string");
+
+    for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+        protozero::pbf_reader item{buffer.data(), i};
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.get_string(), const protozero::end_of_buffer_exception&);
+    }
+}
+
+TEST_CASE("read string field using get_view: empty") {
+    const std::string buffer = load_data("string/data-empty");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    const auto v = item.get_view();
+    REQUIRE(v.empty());
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read string field using get_view: one") {
+    const std::string buffer = load_data("string/data-one");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    const auto v = item.get_view();
+    REQUIRE(*v.data() == 'x');
+    REQUIRE(v.size() == 1);
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read string field using get_view: string") {
+    const std::string buffer = load_data("string/data-string");
+
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(std::string(item.get_view()) == "foobar");
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read string field using get_view: end of buffer") {
+    const std::string buffer = load_data("string/data-string");
+
+    for (std::string::size_type i = 1; i < buffer.size(); ++i) {
+        protozero::pbf_reader item{buffer.data(), i};
+        REQUIRE(item.next());
+        REQUIRE_THROWS_AS(item.get_view(), const protozero::end_of_buffer_exception&);
+    }
+}
+
+TEST_CASE("write string field") {
+    std::string buffer_test;
+    protozero::pbf_writer pbf_test{buffer_test};
+
+    SECTION("empty") {
+        pbf_test.add_string(1, "");
+        REQUIRE(buffer_test == load_data("string/data-empty"));
+    }
+
+    SECTION("one") {
+        pbf_test.add_string(1, "x");
+        REQUIRE(buffer_test == load_data("string/data-one"));
+    }
+
+    SECTION("string") {
+        pbf_test.add_string(1, "foobar");
+        REQUIRE(buffer_test == load_data("string/data-string"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/string/string_testcase.proto b/third_party/protozero/test/t/string/string_testcase.proto
new file mode 100644
index 00000000000..29601dd8dfb
--- /dev/null
+++ b/third_party/protozero/test/t/string/string_testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestString;
+
+message Test {
+
+    required string s = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/string/testcase.cpp b/third_party/protozero/test/t/string/testcase.cpp
new file mode 100644
index 00000000000..28cb7a0e74f
--- /dev/null
+++ b/third_party/protozero/test/t/string/testcase.cpp
@@ -0,0 +1,17 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestString::Test msg;
+
+    msg.set_s("");
+    write_to_file(msg, "data-empty.pbf");
+
+    msg.set_s("x");
+    write_to_file(msg, "data-one.pbf");
+
+    msg.set_s("foobar");
+    write_to_file(msg, "data-string.pbf");
+}
+
diff --git a/third_party/protozero/test/t/string/writer_test_cases.cpp b/third_party/protozero/test/t/string/writer_test_cases.cpp
new file mode 100644
index 00000000000..603c7844a41
--- /dev/null
+++ b/third_party/protozero/test/t/string/writer_test_cases.cpp
@@ -0,0 +1,38 @@
+
+#include <test.hpp>
+
+#include "t/string/string_testcase.pb.h"
+
+TEST_CASE("write string field and check with libprotobuf") {
+
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    TestString::Test msg;
+
+    SECTION("empty") {
+        pw.add_string(1, "");
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.s().empty());
+    }
+
+    SECTION("one") {
+        pw.add_string(1, "x");
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.s() == "x");
+    }
+
+    SECTION("string") {
+        pw.add_string(1, "foobar");
+
+        msg.ParseFromString(buffer);
+
+        REQUIRE(msg.s() == "foobar");
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/tag_and_type/data-combined.pbf b/third_party/protozero/test/t/tag_and_type/data-combined.pbf
new file mode 100644
index 00000000000..90a20f84295
--- /dev/null
+++ b/third_party/protozero/test/t/tag_and_type/data-combined.pbf
@@ -0,0 +1,3 @@
+
+
+ 
\ No newline at end of file
diff --git a/third_party/protozero/test/t/tag_and_type/data-not-packed.pbf b/third_party/protozero/test/t/tag_and_type/data-not-packed.pbf
new file mode 100644
index 00000000000..014f68d293c
--- /dev/null
+++ b/third_party/protozero/test/t/tag_and_type/data-not-packed.pbf
@@ -0,0 +1,2 @@
+
+
\ No newline at end of file
diff --git a/third_party/protozero/test/t/tag_and_type/data-packed.pbf b/third_party/protozero/test/t/tag_and_type/data-packed.pbf
new file mode 100644
index 00000000000..25a9dc1466a
--- /dev/null
+++ b/third_party/protozero/test/t/tag_and_type/data-packed.pbf
@@ -0,0 +1,2 @@
+
+
\ No newline at end of file
diff --git a/third_party/protozero/test/t/tag_and_type/reader_test_cases.cpp b/third_party/protozero/test/t/tag_and_type/reader_test_cases.cpp
new file mode 100644
index 00000000000..35ca7b1d8b7
--- /dev/null
+++ b/third_party/protozero/test/t/tag_and_type/reader_test_cases.cpp
@@ -0,0 +1,89 @@
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include <test.hpp>
+
+enum class ExampleMsg : protozero::pbf_tag_type {
+    repeated_uint32_x = 1
+};
+
+inline std::vector<uint32_t> read_data(const std::string& data) {
+    std::vector<uint32_t> values;
+
+    protozero::pbf_message<ExampleMsg> message{data};
+    while (message.next()) {
+        switch (message.tag_and_type()) {
+            case tag_and_type(ExampleMsg::repeated_uint32_x, protozero::pbf_wire_type::length_delimited): {
+                    const auto xit = message.get_packed_uint32();
+                    for (const auto value : xit) {
+                        values.push_back(value);
+                    }
+                }
+                break;
+            case tag_and_type(ExampleMsg::repeated_uint32_x, protozero::pbf_wire_type::varint): {
+                    const auto value = message.get_uint32();
+                    values.push_back(value);
+                }
+                break;
+            default:
+                message.skip();
+        }
+    }
+
+    return values;
+}
+
+inline std::vector<uint32_t> read_data_packed(const std::string& data) {
+    std::vector<uint32_t> values;
+
+    protozero::pbf_message<ExampleMsg> message{data};
+    while (message.next(ExampleMsg::repeated_uint32_x, protozero::pbf_wire_type::length_delimited)) {
+        const auto xit = message.get_packed_uint32();
+        for (const auto value : xit) {
+            values.push_back(value);
+        }
+    }
+
+    return values;
+}
+
+TEST_CASE("read not packed repeated field with tag_and_type") {
+    const auto values = read_data(load_data("tag_and_type/data-not-packed"));
+
+    REQUIRE(values.size() == 3);
+    const std::vector<uint32_t> result{10, 11, 12};
+    REQUIRE(values == result);
+}
+
+TEST_CASE("read not packed repeated field with tag_and_type using next(...)") {
+    const auto values = read_data_packed(load_data("tag_and_type/data-not-packed"));
+
+    REQUIRE(values.empty());
+}
+
+TEST_CASE("read packed repeated field with tag_and_type") {
+    const auto values = read_data(load_data("tag_and_type/data-packed"));
+
+    REQUIRE(values.size() == 3);
+    const std::vector<uint32_t> result{20, 21, 22};
+    REQUIRE(values == result);
+}
+
+TEST_CASE("read packed repeated field with tag_and_type using next(...)") {
+    const auto values = read_data_packed(load_data("tag_and_type/data-packed"));
+
+    REQUIRE(values.size() == 3);
+    const std::vector<uint32_t> result{20, 21, 22};
+    REQUIRE(values == result);
+}
+
+TEST_CASE("read combined packed and not-packed repeated field with tag_and_type") {
+    const auto values = read_data(load_data("tag_and_type/data-combined"));
+
+    REQUIRE(values.size() == 9);
+    const std::vector<uint32_t> result{10, 11, 12, 20, 21, 22, 30, 31, 32};
+    REQUIRE(values == result);
+}
+
diff --git a/third_party/protozero/test/t/tag_and_type/testcase.cpp b/third_party/protozero/test/t/tag_and_type/testcase.cpp
new file mode 100644
index 00000000000..fb6bcc83c06
--- /dev/null
+++ b/third_party/protozero/test/t/tag_and_type/testcase.cpp
@@ -0,0 +1,42 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+
+    std::string out;
+
+    {
+        TestTagAndType::TestNotPacked msg;
+        for (uint32_t x = 10; x < 13; ++x) {
+            msg.add_x(x);
+        }
+
+        out.append(write_to_file(msg, "data-not-packed.pbf"));
+    }
+
+    {
+        TestTagAndType::TestPacked msg;
+        for (uint32_t x = 20; x < 23; ++x) {
+            msg.add_x(x);
+        }
+
+        out.append(write_to_file(msg, "data-packed.pbf"));
+    }
+
+    {
+        TestTagAndType::TestNotPacked msg;
+        for (uint32_t x = 30; x < 33; ++x) {
+            msg.add_x(x);
+        }
+
+        std::string mout;
+        msg.SerializeToString(&mout);
+        out.append(mout);
+    }
+
+    std::ofstream d("data-combined.pbf", std::ios_base::out|std::ios_base::binary);
+    assert(d.is_open());
+    d << out;
+}
+
diff --git a/third_party/protozero/test/t/tag_and_type/testcase.proto b/third_party/protozero/test/t/tag_and_type/testcase.proto
new file mode 100644
index 00000000000..bd31efceab8
--- /dev/null
+++ b/third_party/protozero/test/t/tag_and_type/testcase.proto
@@ -0,0 +1,15 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestTagAndType;
+
+message TestNotPacked {
+    repeated int32 x = 1;
+    optional string s = 2;
+}
+
+message TestPacked {
+    repeated int32 x = 1 [packed=true];
+    optional string s = 2;
+}
+
diff --git a/third_party/protozero/test/t/tags/data-tag-1.pbf b/third_party/protozero/test/t/tags/data-tag-1.pbf
new file mode 100644
index 00000000000..83e27c1b8ec
--- /dev/null
+++ b/third_party/protozero/test/t/tags/data-tag-1.pbf
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/third_party/protozero/test/t/tags/data-tag-200.pbf b/third_party/protozero/test/t/tags/data-tag-200.pbf
new file mode 100644
index 00000000000..865ec59c1f6
--- /dev/null
+++ b/third_party/protozero/test/t/tags/data-tag-200.pbf
@@ -0,0 +1 @@
+��
\ No newline at end of file
diff --git a/third_party/protozero/test/t/tags/data-tag-200000.pbf b/third_party/protozero/test/t/tags/data-tag-200000.pbf
new file mode 100644
index 00000000000..cd277145354
--- /dev/null
+++ b/third_party/protozero/test/t/tags/data-tag-200000.pbf
@@ -0,0 +1 @@
+��a�
\ No newline at end of file
diff --git a/third_party/protozero/test/t/tags/data-tag-max.pbf b/third_party/protozero/test/t/tags/data-tag-max.pbf
new file mode 100644
index 00000000000..6b03898b69a
--- /dev/null
+++ b/third_party/protozero/test/t/tags/data-tag-max.pbf
@@ -0,0 +1 @@
+�����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/tags/reader_test_cases.cpp b/third_party/protozero/test/t/tags/reader_test_cases.cpp
new file mode 100644
index 00000000000..3b6a5e73b41
--- /dev/null
+++ b/third_party/protozero/test/t/tags/reader_test_cases.cpp
@@ -0,0 +1,53 @@
+
+#include <test.hpp>
+
+inline void check_tag(const std::string& buffer, protozero::pbf_tag_type tag) {
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.next());
+    REQUIRE(item.tag() == tag);
+    REQUIRE(item.get_int32() == 333L);
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("read tag: 1") {
+    check_tag(load_data("tags/data-tag-1"), 1ul);
+}
+
+TEST_CASE("read tag: 200") {
+    check_tag(load_data("tags/data-tag-200"), 200ul);
+}
+
+TEST_CASE("read tag: 200000") {
+    check_tag(load_data("tags/data-tag-200000"), 200000ul);
+}
+
+TEST_CASE("read tag: max") {
+    check_tag(load_data("tags/data-tag-max"), (1ul << 29u) - 1u);
+}
+
+TEST_CASE("write tags") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("tag 1") {
+        pw.add_int32(1L, 333L);
+        REQUIRE(buffer == load_data("tags/data-tag-1"));
+    }
+
+    SECTION("tag 200") {
+        pw.add_int32(200L, 333L);
+        REQUIRE(buffer == load_data("tags/data-tag-200"));
+    }
+
+    SECTION("tag 200000") {
+        pw.add_int32(200000L, 333L);
+        REQUIRE(buffer == load_data("tags/data-tag-200000"));
+    }
+
+    SECTION("tag max") {
+        pw.add_int32(static_cast<int32_t>((1ul << 29u) - 1u), 333L);
+        REQUIRE(buffer == load_data("tags/data-tag-max"));
+    }
+}
+
diff --git a/third_party/protozero/test/t/tags/testcase.cpp b/third_party/protozero/test/t/tags/testcase.cpp
new file mode 100644
index 00000000000..d5724e92fdb
--- /dev/null
+++ b/third_party/protozero/test/t/tags/testcase.cpp
@@ -0,0 +1,32 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+
+    {
+        TestTags::Test1 msg;
+        msg.set_i(333);
+        write_to_file(msg, "data-tag-1.pbf");
+    }
+
+    {
+        TestTags::Test200 msg;
+        msg.set_i(333);
+        write_to_file(msg, "data-tag-200.pbf");
+    }
+
+    {
+        TestTags::Test200000 msg;
+        msg.set_i(333);
+        write_to_file(msg, "data-tag-200000.pbf");
+    }
+
+    {
+        TestTags::TestMax msg;
+        msg.set_i(333);
+        write_to_file(msg, "data-tag-max.pbf");
+    }
+
+}
+
diff --git a/third_party/protozero/test/t/tags/testcase.proto b/third_party/protozero/test/t/tags/testcase.proto
new file mode 100644
index 00000000000..5251af822ea
--- /dev/null
+++ b/third_party/protozero/test/t/tags/testcase.proto
@@ -0,0 +1,29 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestTags;
+
+message Test1 {
+
+    required int32 i = 1;
+
+}
+
+message Test200 {
+
+    required int32 i = 200;
+
+}
+
+message Test200000 {
+
+    required int32 i = 200000;
+
+}
+
+message TestMax {
+
+    required int32 i = 536870911;
+
+}
+
diff --git a/third_party/protozero/test/t/uint32/data-max.pbf b/third_party/protozero/test/t/uint32/data-max.pbf
new file mode 100644
index 00000000000..909ea9ad3ec
--- /dev/null
+++ b/third_party/protozero/test/t/uint32/data-max.pbf
@@ -0,0 +1 @@
+����
\ No newline at end of file
diff --git a/third_party/protozero/test/t/uint32/data-pos.pbf b/third_party/protozero/test/t/uint32/data-pos.pbf
new file mode 100644
index 00000000000..e19a122a540
--- /dev/null
+++ b/third_party/protozero/test/t/uint32/data-pos.pbf
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/uint32/data-pos200.pbf b/third_party/protozero/test/t/uint32/data-pos200.pbf
new file mode 100644
index 00000000000..d9eeb99052b
--- /dev/null
+++ b/third_party/protozero/test/t/uint32/data-pos200.pbf
@@ -0,0 +1 @@
+�

\ No newline at end of file
diff --git a/third_party/protozero/test/t/uint32/data-zero.pbf b/third_party/protozero/test/t/uint32/data-zero.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/uint32/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/uint32/reader_test_cases.cpp b/third_party/protozero/test/t/uint32/reader_test_cases.cpp
new file mode 100644
index 00000000000..0036a47432f
--- /dev/null
+++ b/third_party/protozero/test/t/uint32/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE uint32
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint32_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/uint32/testcase.cpp b/third_party/protozero/test/t/uint32/testcase.cpp
new file mode 100644
index 00000000000..d5533bee99b
--- /dev/null
+++ b/third_party/protozero/test/t/uint32/testcase.cpp
@@ -0,0 +1,20 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestUInt32::Test msg;
+
+    msg.set_i(0ul);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(std::numeric_limits<uint32_t>::max());
+    write_to_file(msg, "data-max.pbf");
+}
+
diff --git a/third_party/protozero/test/t/uint32/testcase.proto b/third_party/protozero/test/t/uint32/testcase.proto
new file mode 100644
index 00000000000..dcca91b9ab1
--- /dev/null
+++ b/third_party/protozero/test/t/uint32/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestUInt32;
+
+message Test {
+
+    required uint32 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/uint64/data-max.pbf b/third_party/protozero/test/t/uint64/data-max.pbf
new file mode 100644
index 00000000000..1c2f041a6bc
--- /dev/null
+++ b/third_party/protozero/test/t/uint64/data-max.pbf
@@ -0,0 +1 @@
+���������

\ No newline at end of file
diff --git a/third_party/protozero/test/t/uint64/data-pos.pbf b/third_party/protozero/test/t/uint64/data-pos.pbf
new file mode 100644
index 00000000000..e19a122a540
--- /dev/null
+++ b/third_party/protozero/test/t/uint64/data-pos.pbf
@@ -0,0 +1 @@
+

\ No newline at end of file
diff --git a/third_party/protozero/test/t/uint64/data-pos200.pbf b/third_party/protozero/test/t/uint64/data-pos200.pbf
new file mode 100644
index 00000000000..d9eeb99052b
--- /dev/null
+++ b/third_party/protozero/test/t/uint64/data-pos200.pbf
@@ -0,0 +1 @@
+�

\ No newline at end of file
diff --git a/third_party/protozero/test/t/uint64/data-zero.pbf b/third_party/protozero/test/t/uint64/data-zero.pbf
new file mode 100644
index 00000000000..268720a2e79
Binary files /dev/null and b/third_party/protozero/test/t/uint64/data-zero.pbf differ
diff --git a/third_party/protozero/test/t/uint64/reader_test_cases.cpp b/third_party/protozero/test/t/uint64/reader_test_cases.cpp
new file mode 100644
index 00000000000..b9ee58510a0
--- /dev/null
+++ b/third_party/protozero/test/t/uint64/reader_test_cases.cpp
@@ -0,0 +1,9 @@
+
+#include <test.hpp>
+
+#define PBF_TYPE uint64
+#define PBF_TYPE_IS_SIGNED 0
+using cpp_type = uint64_t;
+
+#include <scalar_access.hpp>
+
diff --git a/third_party/protozero/test/t/uint64/testcase.cpp b/third_party/protozero/test/t/uint64/testcase.cpp
new file mode 100644
index 00000000000..732bf42699d
--- /dev/null
+++ b/third_party/protozero/test/t/uint64/testcase.cpp
@@ -0,0 +1,20 @@
+
+#include <testcase.hpp>
+#include "testcase.pb.h"
+
+int main(int c, char *argv[]) {
+    TestUInt64::Test msg;
+
+    msg.set_i(0ul);
+    write_to_file(msg, "data-zero.pbf");
+
+    msg.set_i(1);
+    write_to_file(msg, "data-pos.pbf");
+
+    msg.set_i(200);
+    write_to_file(msg, "data-pos200.pbf");
+
+    msg.set_i(std::numeric_limits<uint64_t>::max());
+    write_to_file(msg, "data-max.pbf");
+}
+
diff --git a/third_party/protozero/test/t/uint64/testcase.proto b/third_party/protozero/test/t/uint64/testcase.proto
new file mode 100644
index 00000000000..e0524c0fad3
--- /dev/null
+++ b/third_party/protozero/test/t/uint64/testcase.proto
@@ -0,0 +1,11 @@
+
+option optimize_for = LITE_RUNTIME;
+
+package TestUInt64;
+
+message Test {
+
+    required uint64 i = 1;
+
+}
+
diff --git a/third_party/protozero/test/t/vector_tile/data.vector.pbf b/third_party/protozero/test/t/vector_tile/data.vector.pbf
new file mode 100644
index 00000000000..5c5b19f4590
Binary files /dev/null and b/third_party/protozero/test/t/vector_tile/data.vector.pbf differ
diff --git a/third_party/protozero/test/t/vector_tile/reader_test_cases.cpp b/third_party/protozero/test/t/vector_tile/reader_test_cases.cpp
new file mode 100644
index 00000000000..4d0c72916e4
--- /dev/null
+++ b/third_party/protozero/test/t/vector_tile/reader_test_cases.cpp
@@ -0,0 +1,153 @@
+
+#include <test.hpp>
+
+#include <string>
+#include <vector>
+
+// Input data.vector is encoded according to
+// https://github.com/mapbox/mapnik-vector-tile/blob/master/proto/vector_tile.proto
+
+static std::string get_name(protozero::pbf_reader layer) { // copy!
+    while (layer.next(1)) { // required string name
+        return layer.get_string();
+    }
+    return "";
+}
+
+TEST_CASE("reading vector tiles") {
+    static const std::vector<std::string> expected_layer_names = {
+        "landuse", "waterway", "water", "aeroway", "barrier_line", "building",
+        "landuse_overlay", "tunnel", "road", "bridge", "admin",
+        "country_label_line", "country_label", "marine_label", "state_label",
+        "place_label", "water_label", "area_label", "rail_station_label",
+        "airport_label", "road_label", "waterway_label", "building_label"
+    };
+
+    const std::string buffer = load_data("vector_tile/data.vector");
+    protozero::pbf_reader item{buffer};
+    std::vector<std::string> layer_names;
+
+    SECTION("iterate over message using next()") {
+        while (item.next()) {
+            if (item.tag() == 3) { // repeated message Layer
+                protozero::pbf_reader layer{item.get_message()};
+                while (layer.next()) {
+                    switch (layer.tag()) {
+                        case 1: // required string name
+                            layer_names.push_back(layer.get_string());
+                            break;
+                        default:
+                            layer.skip();
+                    }
+                }
+            } else {
+                item.skip();
+            }
+        }
+
+        REQUIRE(layer_names == expected_layer_names);
+    }
+
+    SECTION("iterate over message using next(tag)") {
+        while (item.next(3)) { // repeated message Layer
+            protozero::pbf_reader layermsg{item.get_message()};
+            while (layermsg.next(1)) { // required string name
+                layer_names.push_back(layermsg.get_string());
+            }
+        }
+
+        REQUIRE(layer_names == expected_layer_names);
+    }
+
+    SECTION("iterate over message using next(tag, type)") {
+        while (item.next(3, protozero::pbf_wire_type::length_delimited)) { // repeated message Layer
+            protozero::pbf_reader layermsg{item.get_message()};
+            while (layermsg.next(1, protozero::pbf_wire_type::length_delimited)) { // required string name
+                layer_names.push_back(layermsg.get_string());
+            }
+        }
+
+        REQUIRE(layer_names == expected_layer_names);
+    }
+
+    SECTION("iterate over features in road layer") {
+        int n=0;
+        int n_id = 0;
+        int n_geomtype = 0;
+        while (item.next(3)) { // repeated message Layer
+            protozero::pbf_reader layer{item.get_message()};
+            std::string name = get_name(layer);
+            if (name == "road") {
+                while (layer.next(2)) { // repeated Feature
+                    ++n;
+                    protozero::pbf_reader feature{layer.get_message()};
+                    while (feature.next()) {
+                        switch (feature.tag()) {
+                            case 1: { // optional uint64 id
+                                const auto id = feature.get_uint64();
+                                REQUIRE(id >=   1ULL);
+                                REQUIRE(id <= 504ULL);
+                                ++n_id;
+                                break;
+                            }
+                            case 3: { // optional GeomType
+                                const auto geom_type = feature.get_uint32();
+                                REQUIRE(geom_type >= 1UL);
+                                REQUIRE(geom_type <= 3UL);
+                                ++n_geomtype;
+                                break;
+                            }
+                            default:
+                                feature.skip();
+                        }
+                    }
+                }
+            }
+        }
+
+        REQUIRE(n == 502);
+        REQUIRE(n_id == 502);
+        REQUIRE(n_geomtype == 502);
+    }
+
+    SECTION("iterate over features in road layer using tag_and_type") {
+        int n=0;
+        int n_id = 0;
+        int n_geomtype = 0;
+        while (item.next(3)) { // repeated message Layer
+            protozero::pbf_reader layer{item.get_message()};
+            std::string name = get_name(layer);
+            if (name == "road") {
+                while (layer.next(2)) { // repeated Feature
+                    ++n;
+                    protozero::pbf_reader feature{layer.get_message()};
+                    while (feature.next()) {
+                        switch (feature.tag_and_type()) {
+                            case protozero::tag_and_type(1, protozero::pbf_wire_type::varint): { // optional uint64 id
+                                const auto id = feature.get_uint64();
+                                REQUIRE(id >=   1ULL);
+                                REQUIRE(id <= 504ULL);
+                                ++n_id;
+                                break;
+                            }
+                            case protozero::tag_and_type(3, protozero::pbf_wire_type::varint): { // optional GeomType
+                                const auto geom_type = feature.get_uint32();
+                                REQUIRE(geom_type >= 1UL);
+                                REQUIRE(geom_type <= 3UL);
+                                ++n_geomtype;
+                                break;
+                            }
+                            default:
+                                feature.skip();
+                        }
+                    }
+                }
+            }
+        }
+
+        REQUIRE(n == 502);
+        REQUIRE(n_id == 502);
+        REQUIRE(n_geomtype == 502);
+    }
+}
+
diff --git a/third_party/protozero/test/t/wrong_type_access/reader_test_cases.cpp b/third_party/protozero/test/t/wrong_type_access/reader_test_cases.cpp
new file mode 100644
index 00000000000..377dd397d0c
--- /dev/null
+++ b/third_party/protozero/test/t/wrong_type_access/reader_test_cases.cpp
@@ -0,0 +1,55 @@
+
+#include <test.hpp>
+
+// protobuf wire type 0
+TEST_CASE("check assert on non-varint access to varint") {
+    const std::string buffer = load_data("int32/data-zero");
+
+    protozero::pbf_reader item{buffer};
+    REQUIRE(item.next());
+
+    REQUIRE(item.get_int32() == 0);
+    REQUIRE_THROWS_AS(item.get_fixed64(), const assert_error&);
+    REQUIRE_THROWS_AS(item.get_string(), const assert_error&);
+    REQUIRE_THROWS_AS(item.get_fixed32(), const assert_error&);
+}
+
+// protobuf wire type 1
+TEST_CASE("check assert on non-fixed access to fixed64") {
+    const std::string buffer = load_data("fixed64/data-zero");
+
+    protozero::pbf_reader item{buffer};
+    REQUIRE(item.next());
+
+    REQUIRE_THROWS_AS(item.get_int32(), const assert_error&);
+    REQUIRE(item.get_fixed64() == 0);
+    REQUIRE_THROWS_AS(item.get_string(), const assert_error&);
+    REQUIRE_THROWS_AS(item.get_fixed32(), const assert_error&);
+}
+
+// protobuf wire type 2
+TEST_CASE("check assert on non-string access to string") {
+    const std::string buffer = load_data("string/data-string");
+
+    protozero::pbf_reader item{buffer};
+    REQUIRE(item.next());
+
+    REQUIRE_THROWS_AS(item.get_int32(), const assert_error&);
+    REQUIRE_THROWS_AS(item.get_fixed64(), const assert_error&);
+    REQUIRE(item.get_string() == "foobar");
+    REQUIRE_THROWS_AS(item.get_fixed32(), const assert_error&);
+}
+
+// protobuf wire type 5
+TEST_CASE("check assert on non-fixed access to fixed32") {
+    const std::string buffer = load_data("fixed32/data-zero");
+
+    protozero::pbf_reader item{buffer};
+    REQUIRE(item.next());
+
+    REQUIRE_THROWS_AS(item.get_int32(), const assert_error&);
+    REQUIRE_THROWS_AS(item.get_fixed64(), const assert_error&);
+    REQUIRE_THROWS_AS(item.get_string(), const assert_error&);
+    REQUIRE(item.get_fixed32() == 0);
+}
+
diff --git a/third_party/protozero/test/unit/CMakeLists.txt b/third_party/protozero/test/unit/CMakeLists.txt
new file mode 100644
index 00000000000..8d9651cc2f8
--- /dev/null
+++ b/third_party/protozero/test/unit/CMakeLists.txt
@@ -0,0 +1,23 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake config
+#
+#  protozero unit tests
+#
+#-----------------------------------------------------------------------------
+
+set(UNIT_TESTS data_view
+               basic
+               endian
+               exceptions
+               varint
+               zigzag)
+
+string(REGEX REPLACE "([^;]+)" "test_\\1.cpp" _test_sources "${UNIT_TESTS}")
+
+add_executable(unit_tests main.cpp ${_test_sources})
+
+add_test(NAME unit_tests COMMAND unit_tests)
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/protozero/test/unit/main.cpp b/third_party/protozero/test/unit/main.cpp
new file mode 100644
index 00000000000..fda358168f5
--- /dev/null
+++ b/third_party/protozero/test/unit/main.cpp
@@ -0,0 +1,4 @@
+
+#define CATCH_CONFIG_MAIN
+#include <test.hpp> // IWYU pragma: keep
+
diff --git a/third_party/protozero/test/unit/test_basic.cpp b/third_party/protozero/test/unit/test_basic.cpp
new file mode 100644
index 00000000000..0ab4a0fcb06
--- /dev/null
+++ b/third_party/protozero/test/unit/test_basic.cpp
@@ -0,0 +1,101 @@
+
+#include <test.hpp>
+
+TEST_CASE("default constructed pbf_reader is okay") {
+    protozero::pbf_reader item;
+
+    REQUIRE(item.length() == 0);
+    REQUIRE_FALSE(item); // test operator bool()
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("empty buffer in pbf_reader is okay") {
+    const std::string buffer;
+    protozero::pbf_reader item{buffer};
+
+    REQUIRE(item.length() == 0);
+    REQUIRE_FALSE(item); // test operator bool()
+    REQUIRE_FALSE(item.next());
+}
+
+TEST_CASE("check every possible value for single byte in buffer") {
+    char buffer;
+    for (int i = 0; i <= 255; ++i) {
+        buffer = static_cast<char>(i);
+        protozero::pbf_reader item{&buffer, 1};
+
+        REQUIRE(item.length() == 1);
+        REQUIRE_FALSE(!item); // test operator bool()
+        REQUIRE_THROWS((item.next(), item.skip()));
+    }
+}
+
+TEST_CASE("next() should throw when illegal wire type is encountered") {
+    const char buffer = 1u << 3u | 7u;
+
+    protozero::pbf_reader item{&buffer, 1};
+    REQUIRE_THROWS_AS(item.next(), const protozero::unknown_pbf_wire_type_exception&);
+}
+
+TEST_CASE("next() should throw when illegal tag is encountered") {
+    std::string data;
+
+    SECTION("tag 0") {
+        protozero::write_varint(std::back_inserter(data), 0u << 3u | 1u);
+    }
+
+    SECTION("tag 19000") {
+        protozero::write_varint(std::back_inserter(data), 19000u << 3u | 1u);
+    }
+
+    SECTION("tag 19001") {
+        protozero::write_varint(std::back_inserter(data), 19001u << 3u | 1u);
+    }
+
+    SECTION("tag 19999") {
+        protozero::write_varint(std::back_inserter(data), 19999u << 3u | 1u);
+    }
+
+    protozero::pbf_reader item{data};
+    REQUIRE_THROWS_AS(item.next(), const protozero::invalid_tag_exception&);
+}
+
+TEST_CASE("next() works when a legal tag is encountered") {
+    std::string data;
+
+    SECTION("tag 1") {
+        protozero::write_varint(std::back_inserter(data), 1u << 3u | 1u);
+    }
+
+    SECTION("tag 18999") {
+        protozero::write_varint(std::back_inserter(data), 18999u << 3u | 1u);
+    }
+
+    SECTION("tag 20000") {
+        protozero::write_varint(std::back_inserter(data), 20000u << 3u | 1u);
+    }
+
+    SECTION("tag 1^29 - 1") {
+        protozero::write_varint(std::back_inserter(data), ((1u << 29u) - 1u) << 3u | 1u);
+    }
+
+    protozero::pbf_reader item{data};
+    REQUIRE(item.next());
+}
+
+TEST_CASE("pbf_writer asserts on invalid tags") {
+    std::string data;
+    protozero::pbf_writer writer{data};
+
+    REQUIRE_THROWS_AS(writer.add_int32(0, 123), const assert_error&);
+    writer.add_int32(1, 123);
+    writer.add_int32(2, 123);
+    writer.add_int32(18999, 123);
+    REQUIRE_THROWS_AS(writer.add_int32(19000, 123), const assert_error&);
+    REQUIRE_THROWS_AS(writer.add_int32(19001, 123), const assert_error&);
+    REQUIRE_THROWS_AS(writer.add_int32(19999, 123), const assert_error&);
+    writer.add_int32(20000, 123);
+    writer.add_int32((1u << 29u) - 1u, 123);
+    REQUIRE_THROWS_AS(writer.add_int32(1u << 29u, 123), const assert_error&);
+}
+
diff --git a/third_party/protozero/test/unit/test_data_view.cpp b/third_party/protozero/test/unit/test_data_view.cpp
new file mode 100644
index 00000000000..da7dfe894b0
--- /dev/null
+++ b/third_party/protozero/test/unit/test_data_view.cpp
@@ -0,0 +1,162 @@
+
+#include <array>
+
+#include <test.hpp>
+
+#include <protozero/types.hpp>
+
+TEST_CASE("default constructed data_view") {
+    const protozero::data_view view{};
+    REQUIRE(view.data() == nullptr);
+    REQUIRE(view.size() == 0); // NOLINT(readability-container-size-empty)
+    REQUIRE(view.empty());
+}
+
+TEST_CASE("data_view from C string") {
+    const protozero::data_view view{"foobar"};
+    REQUIRE(view.data());
+    REQUIRE(view.size() == 6);
+    REQUIRE_FALSE(view.empty());
+}
+
+TEST_CASE("data_view from std::string") {
+    const std::string str{"foobar"};
+    const protozero::data_view view{str};
+    REQUIRE(view.data());
+    REQUIRE(view.size() == 6);
+}
+
+TEST_CASE("data_view from ptr, size") {
+    const std::string str{"foobar"};
+    const protozero::data_view view{str.data(), str.size()};
+    REQUIRE(view.data());
+    REQUIRE(view.size() == 6);
+}
+
+TEST_CASE("data_view from C array") {
+    const char* str = "foobar";
+    const protozero::data_view view{str};
+    REQUIRE(view.data());
+    REQUIRE(view.size() == 6);
+}
+
+TEST_CASE("data_view from std::array") {
+    const std::array<char, 7> str{"foobar"};
+    const protozero::data_view view{str.data(), 6};
+    REQUIRE(view.data());
+    REQUIRE(view.size() == 6);
+}
+
+TEST_CASE("convert data_view to std::string") {
+    const protozero::data_view view{"foobar"};
+
+    const std::string s = std::string(view);
+    REQUIRE(s == "foobar");
+    REQUIRE(std::string(view) == "foobar");
+    REQUIRE(view.to_string() == "foobar");
+}
+
+#ifndef PROTOZERO_USE_VIEW
+// This test only works with our own data_view implementation, because only
+// that one contains the protozero_assert() which generates the exception.
+TEST_CASE("converting default constructed data_view to string fails") {
+    const protozero::data_view view{};
+    REQUIRE_THROWS_AS(view.to_string(), const assert_error&);
+}
+#endif
+
+TEST_CASE("swapping data_view") {
+    protozero::data_view view1{"foo"};
+    protozero::data_view view2{"bar"};
+
+    REQUIRE(view1.to_string() == "foo");
+    REQUIRE(view2.to_string() == "bar");
+
+    using std::swap;
+    swap(view1, view2);
+
+    REQUIRE(view2.to_string() == "foo");
+    REQUIRE(view1.to_string() == "bar");
+}
+
+TEST_CASE("comparing data_views") {
+    const protozero::data_view v1{"foo"};
+    const protozero::data_view v2{"bar"};
+    const protozero::data_view v3{"foox"};
+    const protozero::data_view v4{"foo"};
+    const protozero::data_view v5{"fooooooo", 3};
+    const protozero::data_view v6{"f\0o", 3};
+    const protozero::data_view v7{"f\0obar", 3};
+
+    REQUIRE_FALSE(v1 == v2);
+    REQUIRE_FALSE(v1 == v3);
+    REQUIRE(v1 == v4);
+    REQUIRE(v1 == v5);
+    REQUIRE_FALSE(v1 == v6);
+    REQUIRE_FALSE(v1 == v7);
+    REQUIRE_FALSE(v2 == v3);
+    REQUIRE_FALSE(v2 == v4);
+    REQUIRE_FALSE(v3 == v4);
+    REQUIRE(v4 == v5);
+    REQUIRE(v6 == v7);
+
+    REQUIRE(v1 != v2);
+    REQUIRE(v1 != v3);
+    REQUIRE_FALSE(v1 != v4);
+    REQUIRE_FALSE(v1 != v5);
+    REQUIRE(v1 != v6);
+    REQUIRE(v1 != v7);
+    REQUIRE(v2 != v3);
+    REQUIRE(v2 != v4);
+    REQUIRE(v3 != v4);
+    REQUIRE_FALSE(v4 != v5);
+    REQUIRE_FALSE(v6 != v7);
+}
+
+TEST_CASE("ordering of data_views") {
+    const protozero::data_view v1{"foo"};
+    const protozero::data_view v2{"foo"};
+    const protozero::data_view v3{"bar"};
+    const protozero::data_view v4{"foox"};
+    const protozero::data_view v5{"zzz"};
+
+    REQUIRE(v1.compare(v1) == 0);
+    REQUIRE(v1.compare(v2) == 0);
+    REQUIRE(v1.compare(v3) > 0);
+    REQUIRE(v1.compare(v4) < 0);
+    REQUIRE(v1.compare(v5) < 0);
+
+    REQUIRE(v2.compare(v1) == 0);
+    REQUIRE(v2.compare(v2) == 0);
+    REQUIRE(v2.compare(v3) > 0);
+    REQUIRE(v2.compare(v4) < 0);
+    REQUIRE(v2.compare(v5) < 0);
+
+    REQUIRE(v3.compare(v1) < 0);
+    REQUIRE(v3.compare(v2) < 0);
+    REQUIRE(v3.compare(v3) == 0);
+    REQUIRE(v3.compare(v4) < 0);
+    REQUIRE(v3.compare(v5) < 0);
+
+    REQUIRE(v4.compare(v1) > 0);
+    REQUIRE(v4.compare(v2) > 0);
+    REQUIRE(v4.compare(v3) > 0);
+    REQUIRE(v4.compare(v4) == 0);
+    REQUIRE(v4.compare(v5) < 0);
+
+    REQUIRE(v5.compare(v1) > 0);
+    REQUIRE(v5.compare(v2) > 0);
+    REQUIRE(v5.compare(v3) > 0);
+    REQUIRE(v5.compare(v4) > 0);
+    REQUIRE(v5.compare(v5) == 0);
+
+    REQUIRE(v1 == v2);
+    REQUIRE(v1 <= v2);
+    REQUIRE(v1 >= v2);
+    REQUIRE(v1 < v4);
+    REQUIRE(v3 < v1);
+    REQUIRE(v3 <= v1);
+    REQUIRE(v5 > v1);
+    REQUIRE(v5 >= v1);
+}
+
diff --git a/third_party/protozero/test/unit/test_endian.cpp b/third_party/protozero/test/unit/test_endian.cpp
new file mode 100644
index 00000000000..b774de0bfee
--- /dev/null
+++ b/third_party/protozero/test/unit/test_endian.cpp
@@ -0,0 +1,72 @@
+
+#include <cstdint>
+#include <limits>
+
+#include <test.hpp>
+
+#include <protozero/byteswap.hpp>
+
+static int32_t check_swap_4(int32_t data) noexcept {
+    protozero::detail::byteswap_inplace(&data);
+    protozero::detail::byteswap_inplace(&data);
+    return data;
+}
+
+static int64_t check_swap_8(int64_t data) noexcept {
+    protozero::detail::byteswap_inplace(&data);
+    protozero::detail::byteswap_inplace(&data);
+    return data;
+}
+
+TEST_CASE("byte swapping") {
+    REQUIRE(0 == check_swap_4(0));
+    REQUIRE(1 == check_swap_4(1));
+    REQUIRE(-1 == check_swap_4(-1));
+    REQUIRE(395503 == check_swap_4(395503));
+    REQUIRE(-804022 == check_swap_4(-804022));
+    REQUIRE(std::numeric_limits<int32_t>::max() == check_swap_4(std::numeric_limits<int32_t>::max()));
+    REQUIRE(std::numeric_limits<int32_t>::min() == check_swap_4(std::numeric_limits<int32_t>::min()));
+
+    REQUIRE(0 == check_swap_8(0));
+    REQUIRE(1 == check_swap_8(1));
+    REQUIRE(-1 == check_swap_8(-1));
+    REQUIRE(395503ll == check_swap_8(395503ll));
+    REQUIRE(-804022ll == check_swap_8(-804022ll));
+    REQUIRE(3280329805ll == check_swap_8(3280329805ll));
+    REQUIRE(-2489204041ll == check_swap_8(-2489204041ll));
+    REQUIRE(std::numeric_limits<int64_t>::max() == check_swap_8(std::numeric_limits<int64_t>::max()));
+    REQUIRE(std::numeric_limits<int64_t>::min() == check_swap_8(std::numeric_limits<int64_t>::min()));
+}
+
+TEST_CASE("byte swap uint32_t") {
+    uint32_t a = 17;
+    protozero::detail::byteswap_inplace(&a);
+    protozero::detail::byteswap_inplace(&a);
+
+    REQUIRE(17 == a);
+}
+
+TEST_CASE("byte swap uint64_t") {
+    uint64_t a = 347529808;
+    protozero::detail::byteswap_inplace(&a);
+    protozero::detail::byteswap_inplace(&a);
+
+    REQUIRE(347529808 == a);
+}
+
+TEST_CASE("byte swap double") {
+    double a = 1.1;
+    protozero::detail::byteswap_inplace(&a);
+    protozero::detail::byteswap_inplace(&a);
+
+    REQUIRE(a == Approx(1.1));
+}
+
+TEST_CASE("byte swap float") {
+    float a = 1.1f;
+    protozero::detail::byteswap_inplace(&a);
+    protozero::detail::byteswap_inplace(&a);
+
+    REQUIRE(a == Approx(1.1f));
+}
+
diff --git a/third_party/protozero/test/unit/test_exceptions.cpp b/third_party/protozero/test/unit/test_exceptions.cpp
new file mode 100644
index 00000000000..1c4170cc821
--- /dev/null
+++ b/third_party/protozero/test/unit/test_exceptions.cpp
@@ -0,0 +1,33 @@
+
+#include <test.hpp>
+
+TEST_CASE("exceptions messages for pbf exception") {
+    protozero::exception e;
+    REQUIRE(std::string{e.what()} == std::string{"pbf exception"});
+}
+
+TEST_CASE("exceptions messages for varint too long") {
+    protozero::varint_too_long_exception e;
+    REQUIRE(std::string{e.what()} == std::string{"varint too long exception"});
+}
+
+TEST_CASE("exceptions messages for unknown pbf field type") {
+    protozero::unknown_pbf_wire_type_exception e;
+    REQUIRE(std::string{e.what()} == std::string{"unknown pbf field type exception"});
+}
+
+TEST_CASE("exceptions messages for end of buffer") {
+    protozero::end_of_buffer_exception e;
+    REQUIRE(std::string{e.what()} == std::string{"end of buffer exception"});
+}
+
+TEST_CASE("exceptions messages for invalid tag") {
+    protozero::invalid_tag_exception e;
+    REQUIRE(std::string{e.what()} == std::string{"invalid tag exception"});
+}
+
+TEST_CASE("exceptions messages for invalid length") {
+    protozero::invalid_length_exception e;
+    REQUIRE(std::string{e.what()} == std::string{"invalid length exception"});
+}
+
diff --git a/third_party/protozero/test/unit/test_varint.cpp b/third_party/protozero/test/unit/test_varint.cpp
new file mode 100644
index 00000000000..4a5b72cbb88
--- /dev/null
+++ b/third_party/protozero/test/unit/test_varint.cpp
@@ -0,0 +1,187 @@
+
+#include <test.hpp>
+
+TEST_CASE("max varint length") {
+    REQUIRE(protozero::max_varint_length == 10);
+}
+
+TEST_CASE("varint") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+
+    SECTION("encode/decode int32") {
+        pw.add_int32(1, 17);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+
+        SECTION("get") {
+            REQUIRE(17 == item.get_int32());
+        }
+
+        SECTION("skip") {
+            item.skip();
+        }
+
+        REQUIRE_FALSE(item.next());
+    }
+
+    SECTION("encode/decode uint32") {
+        pw.add_uint32(1, 17u);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+
+        SECTION("get") {
+            REQUIRE(17u == item.get_uint32());
+        }
+
+        SECTION("skip") {
+            item.skip();
+        }
+
+        REQUIRE_FALSE(item.next());
+    }
+
+    SECTION("encode/decode uint64") {
+        pw.add_uint64(1, (1ull << 40u));
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+
+        SECTION("get") {
+            REQUIRE((1ull << 40u) == item.get_uint64());
+        }
+
+        SECTION("skip") {
+            item.skip();
+        }
+
+        REQUIRE_FALSE(item.next());
+    }
+
+    SECTION("short buffer while parsing varint") {
+        pw.add_uint64(1, (1ull << 40u));
+        buffer.resize(buffer.size() - 1); // "remove" last byte from buffer
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+
+        SECTION("get") {
+            REQUIRE_THROWS_AS(item.get_uint64(), const protozero::end_of_buffer_exception&);
+        }
+
+        SECTION("skip") {
+            REQUIRE_THROWS_AS(item.skip(), const protozero::end_of_buffer_exception&);
+        }
+    }
+
+    SECTION("data corruption in buffer while parsing varint)") {
+        pw.add_uint64(1, (1ull << 20u));
+        buffer[buffer.size() - 1] += 0x80; // pretend the varint goes on
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+
+        SECTION("get") {
+            REQUIRE_THROWS_AS(item.get_uint64(), const protozero::end_of_buffer_exception&);
+        }
+
+        SECTION("skip") {
+            REQUIRE_THROWS_AS(item.skip(), const protozero::end_of_buffer_exception&);
+        }
+    }
+
+    SECTION("data corruption in buffer while parsing varint (max length varint)") {
+        pw.add_uint64(1, std::numeric_limits<uint64_t>::max());
+        buffer[buffer.size() - 1] += 0x80; // pretend the varint goes on
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+
+        SECTION("get") {
+            REQUIRE_THROWS_AS(item.get_uint64(), const protozero::varint_too_long_exception&);
+        }
+
+        SECTION("skip") {
+            REQUIRE_THROWS_AS(item.skip(), const protozero::varint_too_long_exception&);
+        }
+    }
+}
+
+TEST_CASE("10-byte varint") {
+    std::string buffer;
+    protozero::pbf_writer pw{buffer};
+    pw.add_uint64(1, 1);
+    buffer.back() = static_cast<char>(0xffu);
+    for (int i = 0; i < 9; ++i) {
+        buffer.push_back(static_cast<char>(0xffu));
+    }
+    buffer.push_back(0x02);
+
+    protozero::pbf_reader item{buffer};
+    REQUIRE(item.next());
+    REQUIRE_THROWS_AS(item.get_uint64(), const protozero::varint_too_long_exception&);
+}
+
+TEST_CASE("lots of varints back and forth") {
+    std::string buffer;
+
+    for (uint32_t n = 0; n < 70000; ++n) {
+        protozero::pbf_writer pw{buffer};
+        pw.add_uint32(1, n);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+        REQUIRE(n == item.get_uint32());
+        REQUIRE_FALSE(item.next());
+        buffer.clear();
+    }
+
+    for (int32_t n = -70000; n < 70000; ++n) {
+        protozero::pbf_writer pw{buffer};
+        pw.add_int32(1, n);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+        REQUIRE(n == item.get_int32());
+        REQUIRE_FALSE(item.next());
+        buffer.clear();
+    }
+
+    for (int32_t n = -70000; n < 70000; ++n) {
+        protozero::pbf_writer pw{buffer};
+        pw.add_sint32(1, n);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+        REQUIRE(n == item.get_sint32());
+        REQUIRE_FALSE(item.next());
+        buffer.clear();
+    }
+
+    for (uint32_t i = 0; i < 63; ++i) {
+        const auto n = static_cast<int64_t>(1ull << i);
+        protozero::pbf_writer pw{buffer};
+        pw.add_int64(1, n);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+        REQUIRE(n == item.get_int64());
+        REQUIRE_FALSE(item.next());
+        buffer.clear();
+    }
+
+    for (uint32_t i = 0; i < 63; ++i) {
+        const int64_t n = - static_cast<int64_t>(1ull << i);
+        protozero::pbf_writer pw{buffer};
+        pw.add_int64(1, n);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+        REQUIRE(n == item.get_int64());
+        REQUIRE_FALSE(item.next());
+        buffer.clear();
+    }
+
+    for (uint32_t i = 0; i < 64; ++i) {
+        const uint64_t n = 1ull << i;
+        protozero::pbf_writer pw{buffer};
+        pw.add_uint64(1, n);
+        protozero::pbf_reader item{buffer};
+        REQUIRE(item.next());
+        REQUIRE(n == item.get_uint64());
+        REQUIRE_FALSE(item.next());
+        buffer.clear();
+    }
+}
+
diff --git a/third_party/protozero/test/unit/test_zigzag.cpp b/third_party/protozero/test/unit/test_zigzag.cpp
new file mode 100644
index 00000000000..1e333a47d07
--- /dev/null
+++ b/third_party/protozero/test/unit/test_zigzag.cpp
@@ -0,0 +1,79 @@
+
+#include <test.hpp>
+
+static_assert(protozero::encode_zigzag32( 0L) == 0UL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag32(-1L) == 1UL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag32( 1L) == 2UL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag32(-2L) == 3UL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag32( 2L) == 4UL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag32( std::numeric_limits<int32_t>::max()) == 2 * static_cast<uint32_t>(std::numeric_limits<int32_t>::max()), "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag32(-std::numeric_limits<int32_t>::max()) == 2 * static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) - 1, "test constexpr zigzag functions");
+
+static_assert(protozero::encode_zigzag64( 0LL) == 0ULL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag64(-1LL) == 1ULL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag64( 1LL) == 2ULL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag64(-2LL) == 3ULL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag64( 2LL) == 4ULL, "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag64( std::numeric_limits<int64_t>::max()) == 2 * static_cast<uint64_t>(std::numeric_limits<int64_t>::max()), "test constexpr zigzag functions");
+static_assert(protozero::encode_zigzag64(-std::numeric_limits<int64_t>::max()) == 2 * static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) - 1, "test constexpr zigzag functions");
+
+static_assert(protozero::decode_zigzag32(0UL) ==  0L, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag32(1UL) == -1L, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag32(2UL) ==  1L, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag32(3UL) == -2L, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag32(4UL) ==  2L, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag32(2 * static_cast<uint32_t>(std::numeric_limits<int32_t>::max())    ) ==  std::numeric_limits<int32_t>::max(), "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag32(2 * static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) - 1) == -std::numeric_limits<int32_t>::max(), "test constexpr zigzag functions");
+
+static_assert(protozero::decode_zigzag64(0ULL) ==  0LL, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag64(1ULL) == -1LL, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag64(2ULL) ==  1LL, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag64(3ULL) == -2LL, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag64(4ULL) ==  2LL, "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag64(2 * static_cast<uint64_t>(std::numeric_limits<int64_t>::max())    ) ==  std::numeric_limits<int64_t>::max(), "test constexpr zigzag functions");
+static_assert(protozero::decode_zigzag64(2 * static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) - 1) == -std::numeric_limits<int64_t>::max(), "test constexpr zigzag functions");
+
+inline constexpr int32_t zz32(int32_t val) {
+    return protozero::decode_zigzag32(protozero::encode_zigzag32(val));
+}
+
+inline constexpr int64_t zz64(int64_t val) {
+    return protozero::decode_zigzag64(protozero::encode_zigzag64(val));
+}
+
+TEST_CASE("zigzag encode some 32 bit values") {
+    REQUIRE(protozero::encode_zigzag32( 0L) == 0UL);
+    REQUIRE(protozero::encode_zigzag32(-1L) == 1UL);
+    REQUIRE(protozero::encode_zigzag32( 1L) == 2UL);
+    REQUIRE(protozero::encode_zigzag32(-2L) == 3UL);
+    REQUIRE(protozero::encode_zigzag32( 2L) == 4UL);
+    REQUIRE(protozero::encode_zigzag32( std::numeric_limits<int32_t>::max()) == 2 * static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
+    REQUIRE(protozero::encode_zigzag32(-std::numeric_limits<int32_t>::max()) == 2 * static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) - 1);
+}
+
+TEST_CASE("zigzag encode some 64 bit values") {
+    REQUIRE(protozero::encode_zigzag64( 0LL) == 0ULL);
+    REQUIRE(protozero::encode_zigzag64(-1LL) == 1ULL);
+    REQUIRE(protozero::encode_zigzag64( 1LL) == 2ULL);
+    REQUIRE(protozero::encode_zigzag64(-2LL) == 3ULL);
+    REQUIRE(protozero::encode_zigzag64( 2LL) == 4ULL);
+    REQUIRE(protozero::encode_zigzag64( std::numeric_limits<int64_t>::max()) == 2 * static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
+    REQUIRE(protozero::encode_zigzag64(-std::numeric_limits<int64_t>::max()) == 2 * static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) - 1);
+}
+
+TEST_CASE("zigzag and back - 32bit") {
+    REQUIRE(zz32( 0L) ==  0L);
+    REQUIRE(zz32( 1L) ==  1L);
+    REQUIRE(zz32(-1L) == -1L);
+    REQUIRE(zz32(std::numeric_limits<int32_t>::max()) == std::numeric_limits<int32_t>::max());
+    REQUIRE(zz32(std::numeric_limits<int32_t>::min()) == std::numeric_limits<int32_t>::min());
+}
+
+TEST_CASE("zigzag and back - 64bit") {
+    REQUIRE(zz64( 0LL) ==  0LL);
+    REQUIRE(zz64( 1LL) ==  1LL);
+    REQUIRE(zz64(-1LL) == -1LL);
+    REQUIRE(zz64(std::numeric_limits<int64_t>::max()) == std::numeric_limits<int64_t>::max());
+    REQUIRE(zz64(std::numeric_limits<int64_t>::min()) == std::numeric_limits<int64_t>::min());
+}
+
diff --git a/third_party/protozero/test/writer_tests.cpp b/third_party/protozero/test/writer_tests.cpp
new file mode 100644
index 00000000000..fda358168f5
--- /dev/null
+++ b/third_party/protozero/test/writer_tests.cpp
@@ -0,0 +1,4 @@
+
+#define CATCH_CONFIG_MAIN
+#include <test.hpp> // IWYU pragma: keep
+
diff --git a/third_party/protozero/tools/CMakeLists.txt b/third_party/protozero/tools/CMakeLists.txt
new file mode 100644
index 00000000000..721a19fbc00
--- /dev/null
+++ b/third_party/protozero/tools/CMakeLists.txt
@@ -0,0 +1,51 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake config
+#
+#  protozero tools
+#
+#-----------------------------------------------------------------------------
+
+# Needs getopt, which is not available on Windows
+if(NOT MSVC)
+    add_executable(pbf-decoder pbf-decoder.cpp)
+
+    add_test(NAME pbf-decoder-no-args
+             COMMAND pbf-decoder)
+    set_tests_properties(pbf-decoder-no-args PROPERTIES
+                         PASS_REGULAR_EXPRESSION "^Usage:")
+
+    add_test(NAME pbf-decoder-help
+             COMMAND pbf-decoder --help)
+    set_tests_properties(pbf-decoder-help PROPERTIES
+                         PASS_REGULAR_EXPRESSION "^Usage:")
+
+    add_test(NAME pbf-decoder-empty
+             COMMAND pbf-decoder "${CMAKE_SOURCE_DIR}/test/t/message/data-opt-empty.pbf")
+    set_tests_properties(pbf-decoder-empty PROPERTIES
+                         PASS_REGULAR_EXPRESSION "^$")
+
+    add_test(NAME pbf-decoder-data
+             COMMAND pbf-decoder "${CMAKE_SOURCE_DIR}/test/t/message/data-message.pbf")
+    set_tests_properties(pbf-decoder-data PROPERTIES
+                         PASS_REGULAR_EXPRESSION "^1:")
+
+    add_test(NAME pbf-decoder-vt
+             COMMAND pbf-decoder -l 999999 -o 0 "${CMAKE_SOURCE_DIR}/test/t/vector_tile/data.vector.pbf")
+    set_tests_properties(pbf-decoder-vt PROPERTIES
+                         PASS_REGULAR_EXPRESSION "^3:")
+
+    add_test(NAME pbf-decoder-fail
+             COMMAND pbf-decoder -l 1 "${CMAKE_SOURCE_DIR}/test/t/vector_tile/data.vector.pbf")
+    set_tests_properties(pbf-decoder-fail PROPERTIES
+                         WILL_FAIL true)
+
+    add_test(NAME pbf-decoder-fail-msg
+             COMMAND pbf-decoder -l 1 "${CMAKE_SOURCE_DIR}/test/t/vector_tile/data.vector.pbf")
+    set_tests_properties(pbf-decoder-fail-msg PROPERTIES
+                         PASS_REGULAR_EXPRESSION "^end of buffer exception")
+
+endif()
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/protozero/tools/pbf-decoder.cpp b/third_party/protozero/tools/pbf-decoder.cpp
new file mode 100644
index 00000000000..5a8d908515f
--- /dev/null
+++ b/third_party/protozero/tools/pbf-decoder.cpp
@@ -0,0 +1,273 @@
+/*****************************************************************************
+
+Protobuf decoder tool
+
+Tool to decode unknown protocol buffer encoded messages. The protocol buffer
+format doesn't contain enough information about the contents of a file to make
+it decodable without the format description usually found in a `.proto` file,
+so this tool does some informed guessing.
+
+Usage:
+
+    pbf-decoder [OPTIONS] [FILENAME]
+
+Use "-" as a file name to read from STDIN.
+
+The output always goes to STDOUT.
+
+Call with --help/-h to see more options.
+
+*****************************************************************************/
+
+#include <protozero/pbf_reader.hpp>
+
+#include <algorithm>
+#include <cctype>
+#include <cstddef>
+#include <exception>
+#include <fstream>
+#include <getopt.h>
+#include <iostream>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+std::string decode(const char* data, std::size_t len, const std::string& indent);
+
+// Try decoding as a nested message
+bool decode_message(std::stringstream& out, const std::string& indent, const protozero::data_view view) {
+    try {
+        const auto nested = decode(view.data(), view.size(), indent + "  ");
+        out << '\n' << nested;
+        return true;
+    } catch (const protozero::exception&) {
+    }
+    return false;
+}
+
+// Try decoding as a string (only printable characters allowed).
+bool decode_printable_string(std::stringstream& out, const protozero::data_view view) {
+    static constexpr const std::size_t max_string_length = 60;
+
+    const std::string str{view.data(), view.size()};
+    if (str.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_:-") != std::string::npos) {
+        return false;
+    }
+
+    if (str.size() > max_string_length) {
+        out << '"' << str.substr(0, max_string_length) << "\"...\n";
+    } else {
+        out << '"' << str << '"' << '\n';
+    }
+    return true;
+}
+
+// Try decoding as a string.
+bool decode_string(std::stringstream& out, const protozero::data_view view) {
+    static constexpr const std::size_t max_string_length = 60;
+
+    std::string str{view.data(), std::min(view.size(), max_string_length)};
+    out << '"';
+
+    for (const auto c : str) {
+        if (std::isprint(c) != 0) {
+            out << c;
+        } else {
+            out << '.';
+        }
+    }
+
+    out << '"' << '\n';
+
+    return true;
+}
+
+// Print a list of numbers from a range
+template <typename TRange>
+void print_number_range(std::stringstream& out, const TRange& range) {
+    bool first = true;
+    for (auto val : range) {
+        if (first) {
+            first = false;
+        } else {
+            out << ',';
+        }
+        out << val;
+    }
+    out << '\n';
+}
+
+// Try decoding as packed repeated double
+bool decode_packed_double(std::stringstream& out, std::size_t size, protozero::pbf_reader& message) {
+    if (size % 8 != 0) {
+        return false;
+    }
+    try {
+        print_number_range(out, message.get_packed_double());
+        return true;
+    } catch (const protozero::exception&) {
+    }
+
+    return false;
+}
+
+// Try decoding as packed repeated float
+bool decode_packed_float(std::stringstream& out, std::size_t size, protozero::pbf_reader& message) {
+    if (size % 4 != 0) {
+        return false;
+    }
+    try {
+        print_number_range(out, message.get_packed_float());
+        return true;
+    } catch (const protozero::exception&) {
+    }
+
+    return false;
+}
+
+// Try decoding as packed repeated varint
+bool decode_packed_varint(std::stringstream& out, protozero::pbf_reader& message) {
+    try {
+        print_number_range(out, message.get_packed_int64());
+        return true;
+    } catch (const protozero::exception&) {
+    }
+
+    return false;
+}
+
+std::string decode(const char* data, std::size_t len, const std::string& indent) {
+    std::stringstream stream;
+    protozero::pbf_reader message{data, len};
+    while (message.next()) {
+        stream << indent << message.tag() << ": ";
+        switch (message.wire_type()) {
+            case protozero::pbf_wire_type::varint: {
+                // This is int32, int64, uint32, uint64, sint32, sint64, bool, or enum.
+                // Try decoding as int64.
+                stream << message.get_int64() << '\n';
+                break;
+            }
+            case protozero::pbf_wire_type::fixed64:
+                // This is fixed64, sfixed64, or double.
+                // Try decoding as a double, because int64_t or uint64_t
+                // would probably be encoded as varint.
+                stream << message.get_double() << '\n';
+                break;
+            case protozero::pbf_wire_type::length_delimited: {
+                // This is string, bytes, embedded messages, or packed repeated fields.
+                protozero::pbf_reader message_copy{message};
+                const auto view = message.get_view();
+
+                decode_message(stream, indent, view) ||
+                    decode_printable_string(stream, view) ||
+                    decode_packed_double(stream, view.size(), message_copy) ||
+                    decode_packed_float(stream, view.size(), message_copy) ||
+                    decode_packed_varint(stream, message_copy) ||
+                    decode_string(stream, view);
+                break;
+            }
+            case protozero::pbf_wire_type::fixed32:
+                // This is fixed32, sfixed32, or float.
+                // Try decoding as a float, because int32_t or uint32_t
+                // would probably be encoded as varint.
+                stream << message.get_float() << '\n';
+                break;
+            default:
+                throw protozero::unknown_pbf_wire_type_exception{};
+        }
+    }
+
+    return stream.str();
+}
+
+void print_help() {
+    std::cout << "Usage: pbf-decoder [OPTIONS] [INPUT_FILE]\n\n"
+              << "Dump raw contents of protobuf encoded file.\n"
+              << "To read from STDIN use '-' as INPUT_FILE.\n"
+              << "\nOptions:\n"
+              << "  -h, --help           This help message\n"
+              << "  -l, --length=LENGTH  Read only LENGTH bytes\n"
+              << "  -o, --offset=OFFSET  Start reading from OFFSET bytes\n";
+}
+
+std::string read_from_file(const char* filename) {
+    std::ifstream file{filename, std::ios::binary};
+    return std::string{std::istreambuf_iterator<char>(file.rdbuf()),
+                       std::istreambuf_iterator<char>()};
+}
+
+std::string read_from_stdin() {
+    return std::string{std::istreambuf_iterator<char>(std::cin.rdbuf()),
+                       std::istreambuf_iterator<char>()};
+}
+
+int main(int argc, char* argv[]) {
+    static struct option long_options[] = {
+        {"help",         no_argument, nullptr, 'h'},
+        {"length", required_argument, nullptr, 'l'},
+        {"offset", required_argument, nullptr, 'o'},
+        {nullptr, 0, nullptr, 0}
+    };
+
+    std::size_t offset = 0;
+    std::size_t length = std::numeric_limits<std::size_t>::max();
+
+    while (true) {
+        const int c = getopt_long(argc, argv, "hl:o:", long_options, nullptr);
+        if (c == -1) {
+            break;
+        }
+
+        switch (c) {
+            case 'h':
+                print_help();
+                return 0;
+            case 'l':
+                length = std::atoll(optarg); // NOLINT(cert-err34-c)
+                                             // good enough for a limited-use tool
+                break;
+            case 'o':
+                offset = std::atoll(optarg); // NOLINT(cert-err34-c)
+                                             // good enough for a limited-use tool
+                break;
+            default:
+                return 1;
+        }
+    }
+
+    const int remaining_args = argc - optind;
+    if (remaining_args != 1) {
+        std::cerr << "Usage: " << argv[0] << " [OPTIONS] [INPUT_FILE]\n\n"
+                  << "Call with --help/-h to see options.\n";
+        return 1;
+    }
+
+    const std::string filename{argv[optind]};
+
+    try {
+        std::string buffer{filename == "-" ? read_from_stdin() :
+                                             read_from_file(argv[optind])};
+
+        if (offset > buffer.size()) {
+            throw std::runtime_error{"offset is larger than file size"};
+        }
+
+        if (offset > 0) {
+            buffer.erase(0, offset);
+        }
+
+        if (length < buffer.size()) {
+            buffer.resize(length);
+        }
+
+        std::cout << decode(buffer.data(), buffer.size(), "");
+    } catch (const std::exception& ex) {
+        std::cerr << ex.what() << '\n';
+        return 1;
+    }
+
+    return 0;
+}
+
diff --git a/third_party/vtzero/.clang-tidy b/third_party/vtzero/.clang-tidy
new file mode 100644
index 00000000000..f75b2822cee
--- /dev/null
+++ b/third_party/vtzero/.clang-tidy
@@ -0,0 +1,48 @@
+---
+Checks: '*,-cert-dcl21-cpp,-cert-err60-cpp,-clang-analyzer-core.CallAndMessage,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-fuchsia-*,-google-runtime-references,-hicpp-no-array-decay,-readability-avoid-const-params-in-decls,-readability-implicit-bool-cast,-readability-implicit-bool-conversion'
+#
+#  Disabled checks:
+#
+#  cert-dcl21-cpp
+#    It is unclear whether this is still a good recommendation in modern C++.
+#
+#  cert-err60-cpp
+#    Reports std::runtime_error as broken which we can't do anything about.
+#
+#  clang-analyzer-core.CallAndMessage
+#    Produces false positives
+#
+#  cppcoreguidelines-owning-memory
+#    Don't want to add dependency on gsl library.
+#
+#  cppcoreguidelines-pro-bounds-array-to-pointer-decay
+#    Limited use and many false positives including for all asserts.
+#
+#  cppcoreguidelines-pro-bounds-pointer-arithmetic
+#    This is a low-level library, it needs to do pointer arithmetic.
+#
+#  fuchsia-*
+#    Much too strict.
+#
+#  google-runtime-references
+#    This is just a matter of preference, and we can't change the interfaces
+#    now anyways.
+#
+#  hicpp-no-array-decay
+#    Limited use and many false positives including for all asserts.
+#
+#  readability-avoid-const-params-in-decls
+#    Inconsistently complaines about some cases but not others. It is nice
+#    to have const in parameters if we don't change them just like with any
+#    other variables.
+#
+#  readability-implicit-bool-cast
+#    Old name for readability-implicit-bool-conversion.
+#
+#  readability-implicit-bool-conversion
+#    I don't think this makes the code more readable.
+#
+WarningsAsErrors: '*'
+HeaderFilterRegex: '\/include\/'
+AnalyzeTemporaryDtors: false
+...
diff --git a/third_party/vtzero/.gitignore b/third_party/vtzero/.gitignore
new file mode 100644
index 00000000000..378eac25d31
--- /dev/null
+++ b/third_party/vtzero/.gitignore
@@ -0,0 +1 @@
+build
diff --git a/third_party/vtzero/.gitmodules b/third_party/vtzero/.gitmodules
new file mode 100644
index 00000000000..6fb530fd58b
--- /dev/null
+++ b/third_party/vtzero/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "test/mvt-fixtures"]
+	path = test/mvt-fixtures
+	url = https://github.com/mapbox/mvt-fixtures.git
diff --git a/third_party/vtzero/.travis.yml b/third_party/vtzero/.travis.yml
new file mode 100644
index 00000000000..8da323b3f06
--- /dev/null
+++ b/third_party/vtzero/.travis.yml
@@ -0,0 +1,178 @@
+#-----------------------------------------------------------------------------
+#
+#  Configuration for continuous integration service at travis-ci.org
+#
+#-----------------------------------------------------------------------------
+
+language: generic
+
+sudo: false
+
+dist: trusty
+
+#-----------------------------------------------------------------------------
+
+# Save common build configurations as shortcuts, so we can reference them later.
+addons_shortcuts:
+  addons_clang35: &clang35
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-3.5' ]
+      packages: [ 'libboost1.55-dev', 'clang-3.5' ]
+  addons_clang38: &clang38
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-3.8' ]
+      packages: [ 'libboost1.55-dev', 'clang-3.8' ]
+  addons_clang39: &clang39
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-3.9' ]
+      packages: [ 'libboost1.55-dev', 'clang-3.9' ]
+  addons_clang40: &clang40
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-4.0' ]
+      packages: [ 'libboost1.55-dev', 'clang-4.0' ]
+  addons_clang50: &clang50
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-5.0' ]
+      packages: [ 'libboost1.55-dev', 'clang-5.0', 'clang-tidy-5.0' ]
+  addons_clang60: &clang60
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-6.0' ]
+      packages: [ 'libboost1.55-dev', 'clang-6.0', 'clang-tidy-6.0' ]
+  addons_gcc48: &gcc48
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libboost1.55-dev', 'g++-4.8', 'gcc-4.8' ]
+  addons_gcc49: &gcc49
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libboost1.55-dev', 'g++-4.9', 'gcc-4.9' ]
+  addons_gcc5: &gcc5
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libboost1.55-dev', 'g++-5', 'gcc-5' ]
+  addons_gcc6: &gcc6
+    apt:
+      sources: [ 'ubuntu-toolchain-r-test' ]
+      packages: [ 'libboost1.55-dev', 'g++-6', 'gcc-6' ]
+
+#-----------------------------------------------------------------------------
+
+matrix:
+  include:
+    - os: linux
+      compiler: "clang-3.5"
+      env: BUILD='Debug' CC=clang-3.5 CXX=clang++-3.5
+      addons: *clang35
+    - os: linux
+      compiler: "clang-3.8"
+      env: BUILD='Debug' CC=clang-3.8 CXX=clang++-3.8
+      addons: *clang38
+    - os: linux
+      compiler: "clang-3.9"
+      env: BUILD='Debug' CC=clang-3.9 CXX=clang++-3.9
+      addons: *clang39
+    - os: linux
+      compiler: "clang-4.0"
+      env: BUILD='Debug' CC=clang-4.0 CXX=clang++-4.0
+      addons: *clang40
+    - os: linux
+      compiler: "clang-5.0"
+      env: BUILD='Debug' CC=clang-5.0 CXX=clang++-5.0
+           CLANG_TIDY=clang-tidy-5.0
+      addons: *clang50
+    - os: linux
+      compiler: "clang-5.0"
+      env: BUILD='Release' CC=clang-5.0 CXX=clang++-5.0
+      addons: *clang50
+    - os: linux
+      compiler: "clang-5.0"
+      env: BUILD='Debug' CC=clang-5.0 CXX=clang++-5.0
+           CXXFLAGS="-fsanitize=address,undefined,integer -fno-sanitize-recover=all -fno-omit-frame-pointer"
+           LDFLAGS="-fsanitize=address,undefined,integer"
+      # LSAN doesn't work on container-based system
+      sudo: required
+      addons: *clang50
+    - os: linux
+      compiler: "clang-6.0"
+      env: BUILD='Debug' CC=clang-6.0 CXX=clang++-6.0
+      addons: *clang60
+    - os: linux
+      compiler: "gcc-4.8"
+      env: BUILD='Debug' CC=gcc-4.8 CXX=g++-4.8
+      addons: *gcc48
+    - os: linux
+      compiler: "gcc-4.9"
+      env: BUILD='Debug' CC=gcc-4.9 CXX=g++-4.9
+           COVERAGE=gcov-4.9
+           CXXFLAGS="--coverage" LDFLAGS="--coverage"
+      addons: *gcc49
+    - os: linux
+      compiler: "gcc-5"
+      env: BUILD='Debug' CC=gcc-5 CXX=g++-5
+           CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=0"
+      addons: *gcc5
+    - os: linux
+      compiler: "gcc-5"
+      env: BUILD='Debug' CC=gcc-5 CXX=g++-5
+           CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=1"
+      addons: *gcc5
+    - os: linux
+      compiler: "gcc-6"
+      env: BUILD='Debug' CC=gcc-6 CXX=g++-6
+      addons: *gcc6
+    - os: linux
+      compiler: "gcc-6"
+      env: BUILD='Debug' CC=gcc-6 CXX=g++-6
+           PROTOZERO_DATA_VIEW=std::experimental::string_view
+      addons: *gcc6
+    - os: linux
+      compiler: "gcc-6"
+      env: BUILD='Release' CC=gcc-6 CXX=g++-6
+      addons: *gcc6
+    - os: osx
+      osx_image: xcode6.4
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode8.3
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode9.1
+      compiler: clang
+      env: BUILD='Debug'
+    - os: osx
+      osx_image: xcode9.1
+      compiler: clang
+      env: BUILD='Release'
+
+#-----------------------------------------------------------------------------
+
+install:
+  - git submodule update --init
+  - (cd ..; git clone --depth=1 https://github.com/mapbox/protozero)
+
+script:
+  - mkdir build
+  - cd build
+  - cmake .. -LA -DCMAKE_BUILD_TYPE=${BUILD} -DPROTOZERO_DATA_VIEW=$PROTOZERO_DATA_VIEW -DCLANG_TIDY=$(which ${CLANG_TIDY})
+  - make VERBOSE=1
+  - ctest --output-on-failure
+  - if [ -n "${CLANG_TIDY}" ]; then make clang-tidy; fi
+  - |
+    if [ -n "${COVERAGE}" ]; then
+      which ${COVERAGE}
+      curl -S -f https://codecov.io/bash -o codecov
+      chmod +x codecov
+      ${COVERAGE} -p $(find test -name 'test_*.o')
+      ./codecov -Z -c -X gcov -F unit_tests
+      ${COVERAGE} -p $(find test -name 'fixture_tests.cpp.o')
+      ./codecov -Z -c -X gcov -F fixture_tests
+    fi
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/vtzero/.ycm_extra_conf.py b/third_party/vtzero/.ycm_extra_conf.py
new file mode 100644
index 00000000000..0b47626ee40
--- /dev/null
+++ b/third_party/vtzero/.ycm_extra_conf.py
@@ -0,0 +1,50 @@
+#-----------------------------------------------------------------------------
+#
+#  Configuration for YouCompleteMe Vim plugin
+#
+#  http://valloric.github.io/YouCompleteMe/
+#
+#-----------------------------------------------------------------------------
+
+from os.path import realpath, dirname
+
+basedir = dirname(realpath(__file__))
+
+# some default flags
+# for more information install clang-3.2-doc package and
+# check UsersManual.html
+flags = [
+'-Werror',
+'-Wall',
+'-Wextra',
+'-pedantic',
+'-Wno-return-type',
+'-Wno-unused-parameter',
+'-Wno-unused-variable',
+
+'-std=c++11',
+
+# '-x' and 'c++' also required
+# use 'c' for C projects
+'-x',
+'c++',
+
+# workaround for https://github.com/Valloric/YouCompleteMe/issues/303
+# also see https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=800618
+'-isystem',
+'/usr/lib/ycmd/clang_includes/',
+
+'-I%s/../protozero/include' % basedir,
+'-I%s/include' % basedir,
+'-I%s/test/include' % basedir,
+'-I%s/test/catch' % basedir,
+]
+
+# youcompleteme is calling this function to get flags
+# You can also set database for flags. Check: JSONCompilationDatabase.html in
+# clang-3.2-doc package
+def FlagsForFile( filename ):
+  return {
+    'flags': flags,
+    'do_cache': True
+  }
diff --git a/third_party/vtzero/CHANGELOG.md b/third_party/vtzero/CHANGELOG.md
new file mode 100644
index 00000000000..7c4cae19c11
--- /dev/null
+++ b/third_party/vtzero/CHANGELOG.md
@@ -0,0 +1,44 @@
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+The format is based on [Keep a Changelog](https://keepachangelog.com/)
+This project adheres to [Semantic Versioning](https://semver.org/).
+
+## [unreleased] -
+
+### Added
+
+### Changed
+
+### Fixed
+
+
+## [1.0.1] - 2018-04-12
+
+### Added
+
+* Some documentation and tests.
+
+### Changed
+
+* Catch exceptions in vtzero-streets example and output error message.
+* Adds a template parameter to the `create_property_map` function allowing
+  mapping between value types.
+
+### Fixed
+
+* The indexes returned by `feature::next_property_indexes()` are now
+  checked against the size of the key/value tables in the layer. If
+  an index is too large a `vtzero::out_of_range_exception` is returned.
+  This way the user code doesn't have to check this. The function
+  `feature::for_each_property()` now also uses these checks.
+
+
+## [1.0.0] - 2018-03-09
+
+First release 
+
+
+[unreleased]: https://github.com/osmcode/libosmium/compare/v1.1.0...HEAD
+
diff --git a/third_party/vtzero/CMakeLists.txt b/third_party/vtzero/CMakeLists.txt
new file mode 100644
index 00000000000..5e660929528
--- /dev/null
+++ b/third_party/vtzero/CMakeLists.txt
@@ -0,0 +1,157 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake config
+#
+#  vtzero
+#
+#-----------------------------------------------------------------------------
+
+cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+
+#-----------------------------------------------------------------------------
+
+project(vtzero)
+
+set(VTZERO_VERSION_MAJOR 1)
+set(VTZERO_VERSION_MINOR 0)
+set(VTZERO_VERSION_PATCH 1)
+
+set(VTZERO_VERSION
+    "${VTZERO_VERSION_MAJOR}.${VTZERO_VERSION_MINOR}.${VTZERO_VERSION_PATCH}")
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+#-----------------------------------------------------------------------------
+
+# This variable must be set to the directory where the mvt-fixtures from the
+# https://github.com/mapbox/mvt-fixtures repository are to be found. Usually
+# this is the directory where the submodule is checked out as described in
+# the README, but you can also set this to a different path, for instance
+# to change the setting while doing development.
+
+set(MVT_FIXTURES "${CMAKE_SOURCE_DIR}/test/mvt-fixtures" CACHE PATH "mvt-fixtures directory for tests")
+
+#-----------------------------------------------------------------------------
+
+option(WERROR "Add -Werror flag to build (turns warnings into errors)" ON)
+
+if(MSVC)
+    add_definitions(-std=c++11 /W3)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS)
+else()
+    add_definitions(-std=c++11 -Wall -Wextra -pedantic -Wsign-compare -Wconversion)
+#    add_definitions(-Weverything -Wno-c++98-compat -Wno-documentation -Wno-switch-enum -Wno-weak-vtables -Wno-padded -Wno-documentation-unknown-command -Wno-exit-time-destructors)
+    if(WERROR)
+        add_definitions(-Werror)
+    endif()
+endif()
+
+include_directories("${CMAKE_SOURCE_DIR}/include")
+
+set(PROTOZERO_DATA_VIEW "" CACHE STRING "Type used for vtzero::data_view")
+if(NOT PROTOZERO_DATA_VIEW STREQUAL "")
+    add_definitions(-DPROTOZERO_DATA_VIEW=${PROTOZERO_DATA_VIEW})
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Find dependencies
+#
+#-----------------------------------------------------------------------------
+
+find_package(Protozero 1.6.0 REQUIRED)
+
+include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
+
+find_package(Boost)
+
+
+#-----------------------------------------------------------------------------
+#
+#  Optional "clang-tidy" target
+#
+#-----------------------------------------------------------------------------
+message(STATUS "Looking for clang-tidy")
+find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-6.0 clang-tidy-5.0)
+
+if(CLANG_TIDY)
+    message(STATUS "Looking for clang-tidy - found ${CLANG_TIDY}")
+    add_custom_target(clang-tidy
+        ${CLANG_TIDY}
+        -p ${CMAKE_BINARY_DIR}
+        ${CMAKE_SOURCE_DIR}/examples/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/t/*.cpp
+    )
+else()
+    message(STATUS "Looking for clang-tidy - not found")
+    message(STATUS "  Build target 'clang-tidy' will not be available.")
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Optional "cppcheck" target
+#
+#-----------------------------------------------------------------------------
+message(STATUS "Looking for cppcheck")
+find_program(CPPCHECK NAMES cppcheck)
+
+if(CPPCHECK)
+    message(STATUS "Looking for cppcheck - found")
+    add_custom_target(cppcheck
+        ${CPPCHECK}
+        -Uassert --std=c++11 --enable=all
+        ${CMAKE_SOURCE_DIR}/examples/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/*.cpp
+        ${CMAKE_SOURCE_DIR}/test/t/*.cpp
+    )
+else()
+    message(STATUS "Looking for cppcheck - not found")
+    message(STATUS "  Build target 'cppcheck' will not be available.")
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Include what you use
+#
+#-----------------------------------------------------------------------------
+message(STATUS "Looking for iwyu")
+find_program(IWYU_TOOL NAMES iwyu_tool)
+
+if(IWYU_TOOL)
+    message(STATUS "Looking for iwyu - found")
+    add_custom_target(iwyu
+        ${IWYU_TOOL} -p ${CMAKE_BINARY_DIR}
+    )
+else()
+    message(STATUS "Looking for iwyu - not found")
+    message(STATUS "  Build target 'iwyu' will not be available.")
+endif()
+
+
+#-----------------------------------------------------------------------------
+#
+#  Installation
+#
+#-----------------------------------------------------------------------------
+
+install(DIRECTORY include/vtzero DESTINATION include)
+
+
+#-----------------------------------------------------------------------------
+
+enable_testing()
+
+add_subdirectory(doc)
+
+add_subdirectory(examples)
+
+add_subdirectory(test)
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/vtzero/CONTRIBUTING.md b/third_party/vtzero/CONTRIBUTING.md
new file mode 100644
index 00000000000..32ed6572dfc
--- /dev/null
+++ b/third_party/vtzero/CONTRIBUTING.md
@@ -0,0 +1,25 @@
+# Contributing to vtzero
+
+## Releasing
+
+To release a new vtzero version:
+
+ - Make sure all tests are passing locally and on travis/appveyor
+ - Update version number in
+   - `CMakeLists.txt` (one place)
+   - `include/vtzero/version.hpp` (two places)
+ - Update CHANGELOG.md
+ - Update UPGRADING.md if necessary
+ - `git commit -m "Release X.Y.Z" include/vtzero/version.hpp CMakeLists.txt CHANGELOG.md UPGRADING.md`
+ - `git tag vX.Y.Z`
+ - `git push`
+ - `git push --tags`
+ - Go to https://github.com/mapbox/vtzero/releases
+   and edit the new release. Put "Version x.y.z" in title and
+   cut-and-paste entry from CHANGELOG.md.
+
+## Updating submodules
+
+Call `git submodule update --recursive --remote` to update to the newest
+version of the mvt fixtures used for testing.
+
diff --git a/third_party/vtzero/EXTERNAL_LICENSES.txt b/third_party/vtzero/EXTERNAL_LICENSES.txt
new file mode 100644
index 00000000000..0f06c09b10a
--- /dev/null
+++ b/third_party/vtzero/EXTERNAL_LICENSES.txt
@@ -0,0 +1,28 @@
+
+==== clara.hpp
+
+Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/third_party/vtzero/LICENSE b/third_party/vtzero/LICENSE
new file mode 100644
index 00000000000..30ba8ace7d4
--- /dev/null
+++ b/third_party/vtzero/LICENSE
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2017, Mapbox
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/third_party/vtzero/README.md b/third_party/vtzero/README.md
new file mode 100644
index 00000000000..ef62c5a09f0
--- /dev/null
+++ b/third_party/vtzero/README.md
@@ -0,0 +1,93 @@
+# vtzero
+
+Tiny and fast vector tile decoder and encoder in C++.
+
+Implements the [Mapbox Vector Tile Specification 2.x](https://www.mapbox.com/vector-tiles/specification).
+
+[![Build Status](https://travis-ci.org/mapbox/vtzero.svg?branch=master)](https://travis-ci.org/mapbox/vtzero)
+[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/mapbox/vtzero?svg=true)](https://ci.appveyor.com/project/Mapbox/vtzero)
+[![Coverage Status](https://codecov.io/gh/mapbox/vtzero/branch/master/graph/badge.svg)](https://codecov.io/gh/mapbox/vtzero)
+
+
+## Depends
+
+* C++11 compiler (GCC 4.8 or higher, clang 3.5 or higher, ...)
+* CMake
+* [Protozero](https://github.com/mapbox/protozero) version >= 1.6.0
+
+
+## Build
+
+First clone `protozero`:
+
+```
+git clone git@github.com:mapbox/protozero.git
+```
+
+Then clone `vtzero` beside `protozero`. The `vtzero` build system will, among
+several places, look for `protozero` at `../protozero`. (If you would like to
+use `protozero` from a different path you can set `PROTOZERO_INCLUDE_DIR` in
+the CMake configuration step.)
+
+Then, inside the `vtzero` directory do:
+
+```
+git submodule update --init
+```
+
+Finally, to build the examples and tests do:
+
+```
+mkdir build
+cd build
+cmake ..
+make
+```
+
+Call `ctest` to run the tests.
+
+
+## Examples
+
+Several examples are provided to show usage of the library.
+
+Call
+
+    examples/vtzero-create
+
+to create test tile named `test.mvt`.
+
+Call
+
+    examples/vtzero-show TILE-FILE
+
+to show the contents of `TILE-FILE`.
+
+You can use
+
+    examples/vtzero-check TILE-FILE
+
+to check vector tile for validity.
+
+
+## Docs
+
+Extensive documentation is available:
+* [Tutorial](doc/tutorial.md) (start here)
+* [Reading vector tiles](doc/reading.md)
+* [Writing vector tiles](doc/writing.md)
+* [Advanced vtzero topics](doc/advanced.md)
+
+Make sure to read all of it before using vtzero. Vtzero isn't the simplest
+library to use, because it always chooses performance over ease of use.
+
+If [Doxygen](http://www.stack.nl/~dimitri/doxygen/) is installed on your
+system, the build process will automatically create the API docs for you.
+The results will be in your build directory under `doc/html`.
+
+
+## Authors
+
+Jochen Topf (jochen@topf.org),
+Dane Springmeyer (dane@mapbox.com)
+
diff --git a/third_party/vtzero/appveyor.yml b/third_party/vtzero/appveyor.yml
new file mode 100644
index 00000000000..24b56079885
--- /dev/null
+++ b/third_party/vtzero/appveyor.yml
@@ -0,0 +1,61 @@
+#-----------------------------------------------------------------------------
+#
+#  Configuration for continuous integration service at appveyor.com
+#
+#-----------------------------------------------------------------------------
+
+platform: x64
+
+image: Visual Studio 2017
+
+clone_depth: 1
+
+#-----------------------------------------------------------------------------
+
+environment:
+  matrix:
+  - config: MSYS2
+    autocrlf: true
+  - config: Debug
+    autocrlf: true
+  - config: RelWithDebInfo
+    autocrlf: true
+  - config: Debug
+    autocrlf: false
+  - config: RelWithDebInfo
+    autocrlf: false
+
+#-----------------------------------------------------------------------------
+
+init:
+  - git config --global core.autocrlf %autocrlf%
+  - git config --get core.autocrlf
+
+# The option --ask=20 is a workaround for a problem with the MSYS2 update
+# process. Without it the following error is printed and the appveyor script
+# halts: "msys2-runtime and catgets are in conflict. Remove catgets?"
+# See also: https://github.com/Alexpux/MSYS2-packages/issues/1141
+install:
+  - cd c:\projects
+  - git clone --depth=1 https://github.com/mapbox/protozero
+  - if [%config%]==[MSYS2] (
+          C:\msys64\usr\bin\pacman --noconfirm --sync --refresh --refresh --sysupgrade --sysupgrade --ask=20
+       && C:\msys64\usr\bin\pacman -Rc --noconfirm mingw-w64-x86_64-gcc-libs
+    )
+
+build_script:
+  - cd c:\projects\vtzero
+  - git submodule update --init
+  - if [%config%]==[MSYS2] (
+        build-msys2.bat
+    ) else (
+        build-appveyor.bat
+    )
+
+# remove garbage VS messages
+# https://help.appveyor.com/discussions/problems/4569-the-target-_convertpdbfiles-listed-in-a-beforetargets-attribute-at-c-does-not-exist-in-the-project-and-will-be-ignored
+before_build:
+  - del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/vtzero/build-appveyor.bat b/third_party/vtzero/build-appveyor.bat
new file mode 100644
index 00000000000..7a572e89bb1
--- /dev/null
+++ b/third_party/vtzero/build-appveyor.bat
@@ -0,0 +1,58 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~ %~f0 ~~~~~~
+
+::show all available env vars
+SET
+ECHO cmake on AppVeyor
+cmake -version
+
+ECHO activating VS cmd prompt && CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+IF EXIST build ECHO deleting build dir... && RD /Q /S build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+MKDIR build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+CD build
+ECHO config^: %config%
+
+::This will produce lots of LNK4099 warnings which can be ignored.
+::Unfortunately they can't be disabled, see
+::https://stackoverflow.com/questions/661606/visual-c-how-to-disable-specific-linker-warnings
+SET CMAKE_CMD=cmake .. ^
+-LA -G "Visual Studio 14 Win64"
+
+ECHO calling^: %CMAKE_CMD%
+%CMAKE_CMD%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET avlogger=
+IF /I "%APPVEYOR%"=="True" SET avlogger=/logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+
+msbuild vtzero.sln ^
+/p:Configuration=%config% ^
+/toolsversion:14.0 ^
+/p:Platform=x64 ^
+/p:PlatformToolset=v140 %avlogger%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ctest --output-on-failure ^
+-C %config% ^
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+:ERROR
+ECHO ~~~~~~ ERROR %~f0 ~~~~~~
+SET EL=%ERRORLEVEL%
+
+:DONE
+IF %EL% NEQ 0 ECHO. && ECHO !!! ERRORLEVEL^: %EL% !!! && ECHO.
+ECHO ~~~~~~ DONE %~f0 ~~~~~~
+
+EXIT /b %EL%
diff --git a/third_party/vtzero/build-msys2.bat b/third_party/vtzero/build-msys2.bat
new file mode 100644
index 00000000000..d3cbcad0a31
--- /dev/null
+++ b/third_party/vtzero/build-msys2.bat
@@ -0,0 +1,18 @@
+echo "Adding MSYS2 to path..."
+SET "PATH=C:\msys64\mingw64\bin;C:\msys64\usr\bin;%PATH%"
+echo %PATH%
+
+echo "Installing MSYS2 packages..."
+bash -lc "pacman -S --needed --noconfirm mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake mingw-w64-x86_64-boost"
+
+echo "Generating makefiles"
+mkdir build
+cd build
+cmake .. -LA -G "MSYS Makefiles"
+
+echo "Building"
+make VERBOSE=1
+
+echo "Testing"
+ctest --output-on-failure
+
diff --git a/third_party/vtzero/cmake/FindProtozero.cmake b/third_party/vtzero/cmake/FindProtozero.cmake
new file mode 100644
index 00000000000..175dd2369fd
--- /dev/null
+++ b/third_party/vtzero/cmake/FindProtozero.cmake
@@ -0,0 +1,63 @@
+#----------------------------------------------------------------------
+#
+#  FindProtozero.cmake
+#
+#  Find the protozero headers.
+#
+#----------------------------------------------------------------------
+#
+#  Usage:
+#
+#    Copy this file somewhere into your project directory, where cmake can
+#    find it. Usually this will be a directory called "cmake" which you can
+#    add to the CMake module search path with the following line in your
+#    CMakeLists.txt:
+#
+#      list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+#
+#    Then add the following in your CMakeLists.txt:
+#
+#      find_package(Protozero [version] [REQUIRED])
+#      include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
+#
+#    The version number is optional. If it is not set, any version of
+#    protozero will do.
+#
+#      if(NOT PROTOZERO_FOUND)
+#          message(WARNING "Protozero not found!\n")
+#      endif()
+#
+#----------------------------------------------------------------------
+#
+#  Variables:
+#
+#    PROTOZERO_FOUND        - True if Protozero was found.
+#    PROTOZERO_INCLUDE_DIR  - Where to find include files.
+#
+#----------------------------------------------------------------------
+
+# find include path
+find_path(PROTOZERO_INCLUDE_DIR protozero/version.hpp
+    PATH_SUFFIXES include
+    PATHS ../protozero
+)
+
+# Check version number
+if(Protozero_FIND_VERSION)
+    file(STRINGS "${PROTOZERO_INCLUDE_DIR}/protozero/version.hpp" _version_define REGEX "#define PROTOZERO_VERSION_STRING")
+    if("${_version_define}" MATCHES "#define PROTOZERO_VERSION_STRING \"([0-9.]+)\"")
+        set(_version "${CMAKE_MATCH_1}")
+    else()
+        set(_version "unknown")
+    endif()
+endif()
+
+#set(PROTOZERO_INCLUDE_DIRS "${PROTOZERO_INCLUDE_DIR}")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Protozero
+                                  REQUIRED_VARS PROTOZERO_INCLUDE_DIR
+                                  VERSION_VAR _version)
+
+
+#----------------------------------------------------------------------
diff --git a/third_party/vtzero/codecov.yml b/third_party/vtzero/codecov.yml
new file mode 100644
index 00000000000..e0e433a4385
--- /dev/null
+++ b/third_party/vtzero/codecov.yml
@@ -0,0 +1,3 @@
+ignore:
+  - "bench"
+  - "test"
\ No newline at end of file
diff --git a/third_party/vtzero/doc/CMakeLists.txt b/third_party/vtzero/doc/CMakeLists.txt
new file mode 100644
index 00000000000..f07a838c145
--- /dev/null
+++ b/third_party/vtzero/doc/CMakeLists.txt
@@ -0,0 +1,36 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake Config
+#
+#  vtzero documentation
+#
+#-----------------------------------------------------------------------------
+
+message(STATUS "Configuring documentation")
+
+message(STATUS "Looking for doxygen")
+find_package(Doxygen)
+
+if(DOXYGEN_FOUND)
+    message(STATUS "Looking for doxygen - found")
+    configure_file(Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+    file(GLOB HEADER_FILES "${CMAKE_SOURCE_DIR}/include/vtzero/*.hpp")
+    add_custom_command(OUTPUT html/index.html
+        COMMAND ${DOXYGEN_EXECUTABLE}
+        ARGS ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+        DEPENDS Doxyfile.in advanced.md doc.md
+                ${HEADER_FILES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Generating API documentation with Doxygen" VERBATIM)
+    add_custom_target(doc ALL
+                      DEPENDS html/index.html)
+else()
+    message(STATUS "Looking for doxygen - not found")
+    message(STATUS "  Disabled making of documentation.")
+endif()
+
+#-----------------------------------------------------------------------------
+message(STATUS "Configuring documentation - done")
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/vtzero/doc/Doxyfile.in b/third_party/vtzero/doc/Doxyfile.in
new file mode 100644
index 00000000000..374c717f8d6
--- /dev/null
+++ b/third_party/vtzero/doc/Doxyfile.in
@@ -0,0 +1,2353 @@
+# Doxyfile 1.8.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all text
+# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
+# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
+# for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = "vtzero"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         = @VTZERO_VERSION@
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "Tiny and fast vector tile decoder and encoder in C++."
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
+# the documentation. The maximum height of the logo should not exceed 55 pixels
+# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
+# to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = "@PROJECT_BINARY_DIR@/doc"
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       =
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        = @PROJECT_SOURCE_DIR@
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
+# new page for each member. If set to NO, the documentation of a member will be
+# part of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines.
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
+# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
+# Fortran. In the later case the parser tries to guess whether the code is fixed
+# or free formatted code, this is the default for Fortran type files), VHDL. For
+# instance to make doxygen treat .inc files as Fortran files (default is PHP),
+# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+#
+# Note For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by by putting a % sign in front of the word
+# or globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO these classes will be included in the various overviews. This option has
+# no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) declarations. If set to NO these declarations will be
+# included in the documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
+# todo list. This list is created by putting \todo commands in the
+# documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
+# test list. This list is created by putting \test commands in the
+# documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES the list
+# will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = YES
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO doxygen will only warn about wrong or incomplete parameter
+# documentation, but not about the absence of documentation.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces.
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = @PROJECT_SOURCE_DIR@/include/vtzero \
+                         @PROJECT_SOURCE_DIR@/doc/doc.md
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: http://www.gnu.org/software/libiconv) for the list of
+# possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank the
+# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
+# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
+# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
+# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
+# *.qsf, *.as and *.js.
+
+FILE_PATTERNS          =
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        = vtzero::detail vtzero_assert
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       =
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER ) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE = @PROJECT_SOURCE_DIR@/doc/doc.md
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# function all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see http://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the
+# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+# cost of reduced performance. This can be particularly helpful with template
+# rich C++ code for which doxygen's built-in parser lacks the necessary type
+# information.
+# Note: The availability of this option depends on whether or not doxygen was
+# compiled with the --with-libclang option.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefor more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra stylesheet files is of importance (e.g. the last
+# stylesheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the stylesheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: http://developer.apple.com/tools/xcode/), introduced with
+# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler ( hhc.exe). If non-empty
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated (
+# YES) or that it should be included in the master .chm file ( NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated (
+# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using prerendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. To get the times font for
+# instance you can specify
+# EXTRA_PACKAGES=times
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
+# for the replacement values of the other commands the user is refered to
+# HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's config
+# file, i.e. a series of assignments. You only have to provide replacements,
+# missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's config file. A template extensions file can be generated
+# using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
+# Definitions (see http://autogen.sf.net) file that captures the structure of
+# the code including all documentation. Note that this feature is still
+# experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
+# in the source code. If set to NO only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES the includes files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
+# class index. If set to NO only the inherited external classes will be listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
+# the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES, the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: YES.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot.
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
+# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
+# gif:cairo:gd, gif:gd, gif:gd:gd and svg.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+PLANTUML_JAR_PATH      =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/third_party/vtzero/doc/advanced.md b/third_party/vtzero/doc/advanced.md
new file mode 100644
index 00000000000..47126020f11
--- /dev/null
+++ b/third_party/vtzero/doc/advanced.md
@@ -0,0 +1,114 @@
+
+# Advanced vtzero topics
+
+## Differences between the protocol buffer specification and the vtzero implementation
+
+The [protobuf specification
+says](https://developers.google.com/protocol-buffers/docs/encoding#optional)
+that a decoder library must handle repeated *non-packed* fields if repeated
+*packed* fields are expected and it must handle multiple repeated packed fields
+as if the items are concatenated. Encoders should never encode fields in this
+way, though, so it is very unlikely that this would ever happen. For
+performance reasons vtzero doesn't handle this case.
+
+## Differences between the vector tile specification and the vtzero implementation
+
+The [vector tile specification](https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md#41-layers)
+clearly says that you can not have two layers with the same
+name in a vector tile. For performance reasons this is neither checked on
+reading nor on writing.
+
+## The `create_vtzero_point` customization point
+
+The vtzero builder classes have several functions which take a `vtzero::point`
+as argument. But chances are that you are using a different point type in your
+code. That's why these functions have overloads taking any type `TPoint` that
+can be converted to a `vtzero::point`. This conversion is done by calling the
+function `create_vtzero_point()`. Vtzero supplies a version of this function
+which will work with any type with members `x` and `y`:
+
+```cpp
+template <typename TPoint>
+vtzero::point create_vtzero_point(TPoint p) noexcept {
+    return {p.x, p.y};
+}
+```
+
+You can define your own overload of that function taking your own point type
+as parameter and returning a `vtzero::point`. Vtzero will find your function
+using [ADL](http://en.cppreference.com/w/cpp/language/adl) which magically
+makes the vtzero builders work with your point type.
+
+## Using the `property_mapper` class when copying layers
+
+Sometimes you want to copy some features of a layer into a new layer. Because
+you only copy some features (and/or only some properties of the features), the
+key and value tables in the layer have to be rebuilt. This is where the
+`property_mapper` class helps you. It keeps the mapping between the index
+values of the old and the new table adding property keys and values as needed
+to the new table.
+
+Here is some code that shows you how to use it:
+
+```cpp
+#include <vtzero/property_mapper.hpp> // you have to include this
+
+vtzero::layer layer = ...; // layer you got from an existing tile
+vtzero::layer_builder layer_builder{...}; // create new layer
+
+// instantiate the property mapper with the old and new layers
+vtzero::property_mapper mapper{layer, layer_builder};
+
+// you'll probably want to iterate over all features in the old layer...
+while (auto feature = layer.next_feature()) {
+    // ... and decide somehow which ones you want to keep
+    if (keep_feature(feature)) {
+        // instantiate a feature builder as usual and copy id and geometry
+        vtzero::geometry_feature_builder feature_builder{layer_builder};
+        if (feature.has_id()) {
+            feature_builder.set_id(feature.id());
+        }
+        feature_builder.set_geometry(feature.geometry());
+
+        // now iterate over all properties...
+        while (auto idxs = feature.next_property_indexes()) {
+            // ... decide which ones to keep,
+            if (keep_property(idxs)) {
+                // ... and add them to the new layer using the mapper
+                feature_builder.add_property(mapper(idxs));
+            }
+        }
+    }
+}
+```
+
+## Protection against huge memory use
+
+When decoding a vector tile we got from an unknown source, we don't know what
+surprises it might contain. Building data structures based on the vector tile
+sometimes means we have to allocate memory and in the worst case this might be
+quite a lot of memory. Vtzero usually doesn't allocate any memory when decoding
+a tile, except when reading properties, when there is space for lookup tables
+allocated. The memory use for these lookup tables is `sizeof(data_view)` times
+the number of entries in the key/value table. In the worst case, when a vector
+tile basically only contains such a table, memory use is proportional to the
+size of the vector tile. But memory use can be an order of magnitude larger
+than the tile size! If you are concerned about memory use, limit the size
+of the vector tiles you give to vtzero.
+
+When reading geometries from vector tiles, vtzero doesn't need much memory
+itself, but the users of vtzero might. In a typical case you might reserve
+enough memory to store, say, a linestring, and then fill that memory. To allow
+you to do this, vtzero tells you about the number of points in the linestring.
+This number comes from the tile and it might be rather large. Vtzero does a
+consistency check comparing the number of points the geometry says it has with
+the number of bytes used for the geometry and it will throw an exception if the
+numbers can't fit. So you are protected against tiny tiles pretending to
+contain a huge geometry. But there still could be a medium-sized tile which
+gets "blown up" into a huge memory hog. Your representation of a linestring
+can be an order of magnitude larger than the minimum 2 bytes per point
+needed in the encoded tile.
+
+So again: If you are concerned about memory use, limit the size of the vector
+tiles you give to vtzero.
+
diff --git a/third_party/vtzero/doc/doc.md b/third_party/vtzero/doc/doc.md
new file mode 100644
index 00000000000..1be4069c65e
--- /dev/null
+++ b/third_party/vtzero/doc/doc.md
@@ -0,0 +1,13 @@
+
+Tiny and fast vector tile decoder and encoder in C++.
+
+This is the API documentation that was automatically created from the
+source code. For more information about vtzero go to
+https://github.com/mapbox/vtzero .
+
+Vtzero is a header-only library. You do not need to compile and link it,
+just include the headers you need.
+
+Everything in namespaces called "detail" is for internal vtzero use only,
+do not depend on it in your code.
+
diff --git a/third_party/vtzero/doc/reading.md b/third_party/vtzero/doc/reading.md
new file mode 100644
index 00000000000..4006024e95c
--- /dev/null
+++ b/third_party/vtzero/doc/reading.md
@@ -0,0 +1,459 @@
+
+# Reading vector tiles
+
+To access the contents of vector tiles with vtzero create a `vector_tile`
+object first with the data of the tile as first argument:
+
+```cpp
+#include <vtzero/vector_tile.hpp> // always needed when reading vector tiles
+
+std::string vt_data = ...;
+vtzero::vector_tile tile{vt_data};
+```
+
+Instead of a string, you can also initialize the `vector_tile` using a
+`vtzero::data_view`. This class contains only a pointer and size referencing
+some data similar to the C++17 `std::string_view` class. It is typedef'd from
+the `protozero::data_view`. See [the protozero
+doc](https://github.com/mapbox/protozero/blob/master/doc/advanced.md#protozero_use_view)
+for more details.
+
+```cpp
+vtzero::data_view vt_data = ...;
+vtzero::vector_tile tile{vt_data};
+```
+
+In both cases the `vector_tile` object contains references to the original
+tile data. You have to make sure this data stays available through the whole
+lifetime of the `vector_tile` object and all the other objects we'll create
+in this tutorial for accessing parts of the vector tile. The data is **not**
+copied by vtzero when accessing vector tiles.
+
+You can think of the `vector_tile` class as a "proxy" class giving you access
+to the decoded data, similarly the classes `layer`, `feature`, and
+`property` described in the next chapters are "proxy" classes, too.
+
+## Accessing layers
+
+Vector tiles consist of a list of layers. The list of layers can be empty
+in which case `tile.empty()` will return true.
+
+The simplest and fasted way to access the layers is through the `next_layer()`
+function:
+
+```cpp
+while (auto layer = tile.next_layer()) {
+    ...
+}
+```
+
+Note that this creates new layer objects on the fly referencing the layer you
+are currently looking at. Once you have iterated over all the layers,
+`next_layer()` will return the "invalid" (default constructed) layer object
+which converts to false in an boolean context.
+
+You can reset the layer iterator to the beginning again if you need to go
+over the layers again:
+
+```cpp
+tile.reset_layer();
+```
+
+Instead of using this external iterator, you can use a different function with
+an internal iterator that calls a function defined by you for each layer. Your
+function must take a `layer&&` as parameter and return `true` if the iteration
+should continue and `false` otherwise:
+
+```cpp
+tile.for_each_layer([&](layer&& l) {
+    // do something with layer
+    return true;
+});
+```
+
+Both the external and internal iteration do basically the same and have the
+same performance characteristics.
+
+You can also access layers through their index or name:
+
+```cpp
+tile.get_layer(3);
+```
+
+will give you the 4th layer in the tile. With
+
+```cpp
+tile.get_layer_by_name("foobar");
+```
+
+you'll get the layer with the specified name. Both will return the invalid
+layer if that layer doesn't exist.
+
+Note that accessing layers by index or name is less efficient than iterating
+over them using `next_layer()` if you are accessing several layers. So usually
+you should only use those function if you want to access one specific layer
+only.
+
+If you need the number of layers, you can call `tile.count_layers()`. This
+function still has to iterate over the layers internally decoding some of the
+data, so it is not cheap.
+
+## The layer
+
+Once you have a layer as described in the previous chapter you can access the
+metadata of this layer easily:
+
+* The version is available with `layer.version()`. Only version 1 and 2 are
+  currently supported by this library.
+* The extent of the tile is available through `layer.extent()`. This is usually
+  4096.
+* The function `layer.name()` returns the name of the layer as `data_view`.
+  This does **not** include a final 0-byte!
+* The number of features is returned by the `layer.num_features()` function.
+  If it doesn't contain any features `layer.empty()` will return true.
+  (Different then the `vector_tile::count_layers()`, the `layer::num_features()`
+  function is `O(1)`).
+
+To access the features call the `next_feature()` function until it returns
+the invalid (default constructed) feature:
+
+```cpp
+while (auto feature = layer.next_feature()) {
+    ...
+}
+```
+
+Use `reset_feature()` to restart the feature iterator from the beginning.
+
+Instead of using this external iterator, you can use a different function with
+an internal iterator that calls a function defined by you for each feature.
+Your function must take a `feature&&` as parameter and return `true` if the
+iteration should continue and `false` otherwise:
+
+```cpp
+layer.for_each_feature([&](feature&& f) {
+    // do something with the feature
+    return true;
+});
+```
+
+Both the external and internal iteration do basically the same and have the
+same performance characteristics.
+
+If you know the ID of a feature you can get the feature using
+`get_feature_by_id()`, but note that this will do a linear search through
+all the features in the layer, decoding each one until it finds the right ID.
+This is almost always **not** what you want.
+
+Note that the feature returned by `next_feature()` or `get_feature_by_id()`
+will internally contain a pointer to the layer it came from. The layer has to
+stay valid as long as the feature is used.
+
+## The feature
+
+You get features from the layer as described in the previous chapter. The
+`feature` class gives you access to the ID, the geometry and the properties
+of the feature. Access the ID using the `id()` method which will return 0
+if no ID is set. You can ask for the existence of the ID using `has_id()`:
+
+```cpp
+auto feature = layer...;
+if (feature.has_id()) {
+    cout << feature.id() << '\n';
+}
+```
+
+The `geometry()` method returns an object of the `geometry` class. It contains
+the geometry type and a reference to the (un-decoded) geometry data. See a
+later chapter on the details of decoding this geometry. You can also directly
+add this geometry to a new feature you are writing.
+
+The number of properties in the feature is returned by the
+`feature::num_properties()` function. If the feature doesn't contain any
+properties `feature.empty()` will return true. (Different then the
+`vector_tile::count_layers()`, the `feature::num_properties()` function is
+`O(1)`).
+
+To access the properties call the `next_property()` function until it returns
+the invalid (default constructed) property:
+
+```cpp
+while (auto property = feature.next_property()) {
+    ...
+}
+```
+
+Use `reset_property()` to restart the property iterator from the beginning.
+
+Instead of using this external iterator, you can use a different function with
+an internal iterator that calls a function defined by you for each property.
+Your function must take a `property&&` as parameter and return `true` if the
+iteration should continue and `false` otherwise:
+
+```cpp
+feature.for_each_property([&](property&& p) {
+    ...
+    return true;
+});
+```
+
+Both the external and internal iteration do basically the same and have the
+same performance characteristics.
+
+## The property
+
+Each property you get from the feature is an object of the `property` class. It
+contains a view of the property key and value. The key is always a string
+encoded in a `vtzero::data_view`, the value can be of different types but is
+always encapsulated in a `property_value` type, a variant type that can be
+converted into whatever type the value really has.
+
+```cpp
+auto property = ...;
+std::string pkey = property.key(); // returns a vtzero::data_view which can
+                                   // be converted to std::string
+property_value pvalue = property.value();
+```
+
+To get the type of the property value, call `type()`:
+
+```cpp
+const auto type = pvalue.type();
+```
+
+If the property value is an int, for instance, you can get it like this:
+
+```cpp
+if (pvalue.type() == property_value_type::int_value)
+    int64_t v = pvalue.int_value();
+}
+```
+
+Instead of accessing the values this way, you'll often use the visitor
+interface. Here is an example where the `print_visitor` struct is used to print
+out the values. In this case one overload is used for all primitive types
+(`double`, `float`, `int`, `uint`, `bool`), one overload is used for the `string_value`
+type which is encoded in a `data_view`. You must make sure your visitor handles
+all those types.
+
+```cpp
+struct print_visitor {
+
+    template <typename T>
+    void operator()(T value) {
+        std::cout << value;
+    }
+
+    void operator()(vtzero::data_view value) {
+        std::cout << std::string(value);
+    }
+
+};
+
+vtzero::apply_visitor(print_visitor{}, pvalue));
+```
+
+All call operators of your visitor class have to return the same type. In the
+case above this was `void`, but it can be something else. That return type
+will be the return type of the `apply_visitor` function. This can be used,
+for instance, to convert the values into one type:
+
+```cpp
+struct to_string_visitor {
+
+    template <typename T>
+    std::string operator()(T value) {
+        reutrn std::to_string(value);
+    }
+
+    std::string operator()(vtzero::data_view value) {
+        return std::string(value);
+    }
+
+};
+
+std::string v = vtzero::apply_visitor(to_string_visitor{}, pvalue);
+```
+
+Sometimes you want to convert the `property_value` type into your own variant
+type. You can use the `vtzero::convert_property_value()` free function for
+this.
+
+Lets say you are using `boost` and this is your variant:
+
+```cpp
+using variant_type = boost::variant<std::string, float, double, int64_t, uint64_t, bool>;
+```
+
+You can then use the following line to convert the data:
+```cpp
+variant_type v = vtzero::convert_property_value<variant_type>(pvalue);
+```
+
+Your variant type must be constructible from all the types `std::string`,
+`float`, `double`, `int64_t`, `uint64_t`, and `bool`. If it is not, you can
+define a mapping between those types and the types you use in your variant
+class.
+
+```cpp
+using variant_type = boost::variant<mystring, double, int64_t, uint64_t, bool>;
+
+struct mapping : vtzero::property_value_mapping {
+    using string_type = mystring; // use your own string type which must be
+                                  // convertible from data_view
+    using float_type = double; // no float in variant, so convert to double
+};
+
+variant_type v = vtzero::convert_property_value<variant_type, mapping>(pvalue);
+```
+
+## Creating a properties map
+
+This linear access to the properties with lazy decoding of each property only
+when it is accessed saves memory allocations, especially if you are only
+interested in very few properties. But sometimes it is easier to create a
+mapping (based on `std::unordered_map` for instance) between keys and values. This is where
+the `vtzero::create_properties_map()` templated free function comes in. It
+needs the map type as template parameter:
+
+```cpp
+using key_type = std::string; // must be something that can be converted from data_view
+using value_type = boost::variant<std::string, float, double, int64_t, uint64_t, bool>;
+using map_type = std::map<key_type, value_type>;
+
+auto feature = ...;
+auto map = create_properties_map<map_type>(feature);
+```
+
+Both `std::map` and `std::unordered_map` are supported as map type, but this
+should also work with any other map type that has an `emplace()` method.
+
+## Geometries
+
+Features must contain a geometry of type UNKNOWN, POINT, LINESTRING, or
+POLYGON. The UNKNOWN type is not further specified by the vector tile spec,
+this library doesn't allow you to do anything with this type. Note that
+multipoint, multilinestring, and multipolygon geometries are also possible,
+they don't have special types.
+
+You can get the geometry type with `feature.geometry_type()`, but usually
+you'll get the geometry with `feature.geometry()`. This will return an object
+of type `vtzero::geometry` which contains the geometry type and a view of
+the raw geometry data. To decode the data you have to call one of the decoder
+free functions `decode_geometry()`, `decode_point_geometry()`,
+`decode_linestring_geometry()`, or `decode_polygon_geometry()`. The first of
+these functions can decode any point, linestring, or polygon geometry. The
+others must be called with a geometry of the specified type and will only
+decode that type.
+
+For all the decoder functions the first parameter is the geometry (as returned
+by `feature.geometry()`), the second parameter is a *handler* object that you
+must implement. The decoder function will call certain callbacks on this object
+that give you part of the geometry data which allows you to use this data in
+any way you like.
+
+The handler for `decode_point_geometry()` must implement the following
+functions:
+
+* `void points_begin(uint32_t count)`: This is called once at the beginning
+  with the number of points. For a point geometry, this will be 1, for
+  multipoint geometries this will be larger.
+* `void points_point(vtzero::point point)`: This is called once for each
+  point.
+* `void points_end()`: This is called once at the end.
+
+The handler for `decode_linestring_geometry()` must implement the following
+functions:
+
+* `void linestring_begin(uint32_t count)`: This is called at the beginning
+  of each linestring with the number of points in this linestring. For a simple
+  linestring this function will only be called once, for a multilinestring
+  it will be called several times.
+* `void linestring_point(vtzero::point point)`: This is called once for each
+  point.
+* `void linestring_end()`: This is called at the end of each linestring.
+
+The handler for `decode_polygon_geometry` must implement the following
+functions:
+
+* `void ring_begin(uint32_t count)`: This is called at the beginning
+  of each ring with the number of points in this ring. For a simple polygon
+  with only one outer ring, this function will only be called once, if there
+  are inner rings or if this is a multipolygon, it will be called several
+  times.
+* `void ring_point(vtzero::point point)`: This is called once for each
+  point.
+* `void ring_end(vtzero::ring_type)`: This is called at the end of each ring.
+  The parameter tells you whether the ring is an outer or inner ring or whether
+  the ring was invalid (if the area is 0).
+
+The handler for `decode_geometry()` must implement all of the functions
+mentioned above for the different types. It is guaranteed that only one
+set of functions will be called depending on the geometry type.
+
+If your handler implements the `result()` method, the decode functions will
+have the return type of the `result()` method and will return whatever
+result returns. If the `result()` method is not available, the decode functions
+return void.
+
+Here is a typical implementation of a linestring handler:
+
+```cpp
+struct linestring_handler {
+
+    using linestring = std::vector<my_point_type>;
+
+    linestring points;
+
+    void linestring_begin(uint32_t count) {
+        points.reserve(count);
+    }
+
+    void linestring_point(vtzero::point point) noexcept {
+        points.push_back(convert_to_my_point(point));
+    }
+
+    void linestring_end() const noexcept {
+    }
+
+    linestring result() {
+        return std::move(points);
+    }
+
+};
+```
+
+Note that the `count` given to the `linestring_begin()` method is used here to
+reserve memory. This is potentially problematic if the count is large. Please
+keep this in mind.
+
+## Accessing the key/value lookup tables in a layer
+
+Vector tile layers contain two tables with all the property keys and all
+property values used in the features in that layer. Vtzero usually handles
+those table lookups internally without you noticing. But sometimes it might
+be necessary to access this data directly.
+
+From the layer object you can get references to the tables:
+
+```cpp
+vtzero::layer layer = ...;
+const auto& kt = layer.key_table();
+const auto& vt = layer.value_table();
+```
+
+Instead you can also lookup keys and values using methods on the layer object:
+```cpp
+vtzero::layer layer = ...;
+const vtzero::data_view k = layer.key(17);
+const vtzero::property_value_view v = layer.value(42);
+```
+
+As usual in vtzero you only get views back, so you need to keep the layer
+object around as long as you are accessing the results of those methods.
+
+Note that the lookup tables are created on first access from the layer data. As
+long as you are not accessing those tables directly or by looking up any
+properties in a feature, the tables are not created and no extra memory is
+used.
+
diff --git a/third_party/vtzero/doc/tutorial.md b/third_party/vtzero/doc/tutorial.md
new file mode 100644
index 00000000000..90283910f2b
--- /dev/null
+++ b/third_party/vtzero/doc/tutorial.md
@@ -0,0 +1,94 @@
+
+# Vtzero Tutorial
+
+The vtzero header-only library is used to read and write vector tile data
+as specified in the [Mapbox Vector Tile
+Specification](https://github.com/mapbox/vector-tile-spec). This document
+assumes that you are familiar with that specification.
+
+## Overview
+
+The library has basically two parts: The part concerned with decoding existing
+vector tiles and the part concerned with creating new vector tiles. You can
+use either one without knowing much about the other side, but it is, of course
+also possible to read parts of a vector tile and stick it into a new one.
+
+Vtzero is trying to do as little work as possible while still giving you a
+reasonably easy to use interface. This means that it will, as much as feasible,
+decode the different parts of a vector tile only when you ask for them. Most
+importantly it will try to avoid memory allocation and it will not copy data
+around unnecessarily but work with references instead.
+
+On the writing side it means that you have to call the API in a specific order
+when adding more data to a vector tile. This allows vtzero to avoid multiple
+copies of the data.
+
+## Basic types
+
+Vtzero contains several basic small (value) types such as `GeomType`,
+`property_value_type`, `index_value`, `index_value_pair`, and `point` which
+hold basic values in a type-safe way. Most of them are defined in `types.hpp`
+(`point` is in `geometry.hpp`).
+
+Sometimes it is useful to be able to print the values of those types, for
+instance when debugging. For this overloads of `operator<<` on `basic_ostream`
+are available in `vtzero/output.hpp`. Include this file and you can use the
+usual `std::cout << some_value;` to print those values.
+
+## Use of asserts and exceptions
+
+The vtzero library uses a lot of asserts to help you use it correctly. It is
+recommended you use debug builds while developing your code, because you'll
+get asserts from vtzero telling you when you use it in a wrong way. This is
+especially important when writing tiles using the builder classes, because
+their methods have to be called in a certain order that might not always be
+obvious but is checked by the asserts.
+
+Exceptions, on the other hand, are used when errors occur during the normal run
+of vtzero. This is especially important on the reading side when vtzero makes
+every effort to handle any kind of input, even if the input data is corrupt
+in some way. (Vtzero can't detect all problems though, your code still has to
+do its own checking, see the [advanced topics](advanced.md) for some more
+information.)
+
+Many vtzero functions can throw exceptions. Most of them fall into these
+categories:
+
+* If the underlying protocol buffers data has some kind of problem, you'll
+  get an exception from the [protozero
+  library](https://github.com/mapbox/protozero/blob/master/doc/tutorial.md#asserts-and-exceptions-in-the-protozero-library).
+  They are all derived from `protozero::exception`.
+* If the protocol buffers data is okay, but the vector tile data is invalid
+  in some way, you'll get an exception from the vtzero library.
+* If any memory allocation failed, you'll get a `std::bad_alloc` exception.
+
+All the exceptions thrown directly by the vtzero library are derived from
+`vtzero::exception`. These exceptions are:
+
+* A `format_exception` is thrown when vector tile encoding isn't valid
+  according to the vector tile specification.
+* A `geometry_exception` is thrown when a geometry encoding isn't valid
+  according to the vector tile specification.
+* A `type_exception` is thrown when a property value is accessed using the
+  wrong type.
+* A `version_exception` is thrown when an unknown version number is found in
+  the layer. Currently vtzero only supports version 1 and 2.
+* An `out_of_range_exception` is thrown when an index into the key or value
+  table in a layer is out of range. This can only happen if the tile data is
+  invalid.
+
+## Include files
+
+Usually you only directly include the following files:
+
+* When reading: `<vtzero/vector_tile.hpp>`
+* When writing: `<vtzero/builder.hpp>`
+* If you need any of the special indexes: `<vtzero/index.hpp>`
+* If you want overloads of `operator<<` for basic types: `<vtzero/output.hpp>`
+* If you need the version: `<vtzero/version.hpp>`
+
+## Reading and writing vector tiles
+
+* [Reading vector tiles](reading.md)
+* [Writing vector tiles](writing.md)
+
diff --git a/third_party/vtzero/doc/writing.md b/third_party/vtzero/doc/writing.md
new file mode 100644
index 00000000000..72200c7c22e
--- /dev/null
+++ b/third_party/vtzero/doc/writing.md
@@ -0,0 +1,539 @@
+
+# Writing vector tiles
+
+Writing vector tiles start with creating a `tile_builder`. This builder will
+then be used to add layers and features in those layers. Once all this is done,
+you call `serialize()` to actually build the vector tile from the data you
+provided to the builders:
+
+```cpp
+#include <vtzero/builder.hpp> // always needed when writing vector tiles
+
+vtzero::tile_builder tbuilder;
+// add lots of data to builder...
+std::string buffer = tbuilder.serialize();
+```
+
+You can also serialize the data into an existing buffer instead:
+
+```cpp
+std::string buffer; // got buffer from somewhere
+tbuilder.serialize(buffer);
+```
+
+## Adding layers to tiles
+
+Once you have a tile builder, you'll first need some layers:
+
+```cpp
+vtzero::tile_builder tbuilder;
+vtzero::layer_builder layer_pois{tbuilder, "pois", 2, 4096};
+vtzero::layer_builder layer_roads{tbuilder, "roads"};
+vtzero::layer_builder layer_forests{tbuilder, "forests"};
+```
+
+Here three layers called "pois", "roads", and "forests" are added. The first
+one explicitly specifies the vector tile version used and the extent. The
+values specified here are the default, so all layers in this example will have
+a version of 2 and an extent of 4096.
+
+If you have read a layer from an existing vector tile and want to copy over
+some of the data, you can use this layer to initialize the new layer in the
+new vector tile with the name, version and extent from the existing layer like
+this:
+
+```cpp
+vtzero::layer some_layer = ...;
+vtzero::layer_builder layer_pois{tbuilder, some_layer};
+// same as...
+vtzero::layer_builder layer_pois{tbuilder, some_layer.name(),
+                                           some_layer.version(),
+                                           some_layer.extent()};
+```
+
+If you want to copy over an existing layer completely, you can use the
+`add_existing_layer()` function instead:
+
+```cpp
+vtzero::layer some_layer = ...;
+vtzero::tile_builder tbuilder;
+tbuilder.add_existing_layer(some_layer);
+```
+
+Or, if you have the encoded layer data available in a `data_view` this also
+works:
+
+```cpp
+vtzero::data_view layer_data = ...;
+vtzero::tile_builder tbuilder;
+tbuilder.add_existing_layer(layer_data);
+```
+
+Note that this call will only store a reference to the data to be added in the
+tile builder. The data will only be copied when the final `serialize()` is
+called, so the input data must still be available then!
+
+You can mix any of the ways of adding a layer to the tile mentioned above. The
+layers will be added to the tile in the order you add them to the
+`tile_builder`.
+
+The tile builder is smart enough to not add empty layers, so you can start
+out with all the layers you might need and if some of them stay empty, they
+will not be added to the tile when `serialize()` is called.
+
+## Adding features to layers
+
+Once we have one or more `layer_builder`s instantiated, we can add features
+to them. This is done through the following feature builder classes:
+
+* `point_feature_builder` to add a feature with a (multi)point geometry,
+* `linestring_feature_builder` to add a feature with a (multi)linestring
+  geometry,
+* `polygon_feature_builder` to add a feature with a (multi)polygon geometry, or
+* `geometry_feature_builder` to add a feature with an existing geometry you
+  got from reading a vector tile.
+
+In all cases you need to instantiate the feature builder class, optionally
+add the feature ID using the `set_id()` method, add the geometry and then
+add all the properties of this feature. You have to keep to this order!
+
+```cpp
+...
+vtzero::layer_builder lbuilder{...};
+{
+    vtzero::point_feature_builder fbuilder{lbuilder};
+    // optionally set the ID
+    fbuilder.set_id(23);
+    // add the geometry (exact calls are different for different feature builders)
+    fbuilder.add_point(99, 33);
+    // add the properties
+    fbuilder.add_property("amenity", "restaurant");
+    // call commit() when you are done
+    fbuilder.commit()
+}
+```
+
+You have to call `commit()` on the feature builder object after you set all the
+data to actually add it to the layer. If you don't do this, the feature will
+not be added to the layer! This can be useful, for instance, if you detect that
+you have an invalid geometry while you are adding the geometry to the feature
+builder. In that case you can call `rollback()` explicitly or just let the
+feature builder go out of scope and it will do the rollback automatically.
+
+Only the first call to `commit()` or `rollback()` will take effect, any further
+calls to these functions on the same feature builder object are ignored.
+
+## Adding a geometry to the feature
+
+There are different ways of adding the geometry to the feature, depending on
+the geometry type.
+
+### Adding a point geometry
+
+Simply call `add_point()` to set the point geometry. There are three different
+overloads for this function. One takes a `vtzero::point`, one takes two
+`uint32_t`s with the x and y coordinates and one takes any type `T` that can
+be converted to a `vtzero::point` using the `create_vtzero_point` function.
+This templated function works on any type that has `x` and `y` members and
+you can create your own overload of this function. See the
+[advanced.md](advanced topics documentation).
+
+### Adding a multipoint geometry
+
+Call `add_points()` with the number of points in the geometry as only argument.
+After that call `set_point()` for each of those points. `set_point()` has
+multiple overloads just like the `add_point()` method described above.
+
+There is also the `add_points_from_container()` function which copies the
+point from any container type supporting the `size()` function and which
+iterator yields a `vtzero::point` or something convertible to it.
+
+### Adding a linestring geometry
+
+Call `add_linestring()` with the number of points in the linestring as only
+argument. After that call `set_point()` for each of those points. `set_point()`
+has multiple overloads just like the `add_point()` method described above.
+
+```cpp
+...
+vtzero::layer_builder lbuilder{...};
+try {
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+    // optionally set the ID
+    fbuilder.set_id(23);
+    // add the geometry
+    fbuilder.add_linestring(2);
+    fbuilder.set_point(1, 2);
+    fbuilder.set_point(3, 4);
+    // add the properties
+    fbuilder.add_property("highway", "primary");
+    fbuilder.add_property("maxspeed", 80);
+    // call commit() when you are done
+    fbuilder.commit()
+} catch (const vtzero::geometry_exception& e) {
+    // if we are here, something was wrong with the geometry.
+}
+```
+
+Note that we have wrapped the feature builder in a try-catch-block here. This
+will ignore all geometry errors (which can happen if two consective points
+are the same creating a zero-length segment).
+
+There are two other versions of the `add_linestring()` function. They take two
+iterators defining a range to get the points from. Dereferencing those
+iterators must yield a `vtzero::point` or something convertible to it. One of
+these functions takes a third argument, the number of points the iterator will
+yield. If this is not available `std::distance(begin, end)` is called which
+internally by the `add_linestring()` function which might be slow depending on
+your iterator type.
+
+### Adding a multilinestring geometry
+
+Adding a multilinestring works just like adding a linestring, just do the
+calls to `add_linestring()` etc. repeatedly for each of the linestrings.
+
+### Adding a polygon geometry
+
+A polygon consists of one outer ring and zero or more inner rings. You have
+to first add the outer ring and then the inner rings, if any.
+
+Call `add_ring()` with the number of points in the ring as only argument. After
+that call `set_point()` for each of those points. `set_point()` has multiple
+overloads just like the `add_point()` method described above. The minimum
+number of points is 4 and the last point must be the same as the first point
+(or call `close_ring()` instead of the last `set_point()`).
+
+```cpp
+...
+vtzero::layer_builder lbuilder{...};
+try {
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+    // optionally set the ID
+    fbuilder.set_id(23);
+    // add the geometry
+    fbuilder.add_ring(5);
+    fbuilder.set_point(1, 1);
+    fbuilder.set_point(1, 2);
+    fbuilder.set_point(2, 2);
+    fbuilder.set_point(2, 1);
+    fbuilder.set_point(1, 1); // or call fbuilder.close_ring() instead
+    // add the properties
+    fbuilder.add_property("landuse", "forest");
+    // call commit() when you are done
+    fbuilder.commit()
+} catch (const vtzero::geometry_exception& e) {
+    // if we are here, something was wrong with the geometry.
+}
+```
+
+Note that we have wrapped the feature builder in a try-catch-block here. This
+will ignore all geometry errors (which can happen if two consective points
+are the same creating a zero-length segment or if the last point is not the
+same as the first point).
+
+There are two other versions of the `add_ring()` function. They take two
+iterators defining a range to get the points from. Dereferencing those
+iterators must yield a `vtzero::point` or something convertible to it. One of
+these functions takes a third argument, the number of points the iterator will
+yield. If this is not available `std::distance(begin, end)` is called which
+internally by the `add_ring()` function which might be slow depending on your
+iterator type.
+
+### Adding a multipolygon geometry
+
+Adding a multipolygon works just like adding a polygon, just do the calls to
+`add_ring()` etc. repeatedly for each of the rings. Make sure to always first
+add an outer ring, then the inner rings in this outer ring, then the next
+outer ring and so on.
+
+### Adding an existing geometry
+
+The `geometry_feature_builder` class is used to add geometries you got from
+reading a vector tile. This is useful when you want to copy over a geometry
+from a feature without decoding it.
+
+```cpp
+auto geom = ... // get geometry from a feature you are reading
+...
+vtzero::tile_builder tb;
+vtzero::layer_builder lb{tb};
+vtzero::geometry_feature_builder fb{lb};
+fb.set_id(123); // optionally set ID
+fb.add_geometry(geom) // add geometry
+fb.add_property("foo", "bar"); // add properties
+fb.commit();
+...
+```
+
+## Adding properties to the feature
+
+A feature can have any number of properties. They are added with the
+`add_property()` method called on the feature builder. There are two different
+ways of doing this. The *simple approach* which does all the work for you and
+the *advanced approach* which can be more efficient, but you have to to some
+more work. It is recommended that you start out with the simple approach and
+only switch to the advanced approach once you have a working program and want
+to get the last bit of performance out of it.
+
+The difference stems from the way properties are encoded in vector tiles. While
+properties "belong" to features, they are really stored in two tables (for the
+keys and values) in the layer. The individual feature only references the
+entries in those tables by index. This make the encoded tile smaller, but it
+means somebody has to manage those tables. In the simple approach this is done
+behind the scenes by the `layer_builder` object, in the advanced approach you
+handle that yourself.
+
+Do not mix the simple and the advanced approach unless you know what you are
+doing.
+
+### The simple approach to adding properties
+
+For the simple approach call `add_property()` with two arguments. The first is
+the key, it must have some kind of string type (`std::string`, `const char*`,
+`vtzero::data_view`, anything really that converts to a `data_view`). The
+second argument is the value, for which most basic C++ types are allowed
+(string types, integer types, double, ...). See the API documentation for the
+constructors of the `encoded_property_value` class for a list.
+
+```cpp
+vtzero::layer_builder lb{...};
+vtzero::linestring_feature_builder fb{lb};
+...
+fb.add_property("waterway", "stream"); // string value
+fb.add_property("name", "Little Creek");
+fb.add_property("width", 1.5); // double value
+...
+```
+
+Sometimes you need to specify exactly which type should be used in the
+encoding. The `encoded_property_value` constructor can take special types for
+that like in the following example, where you force the `sint` encoding:
+
+```cpp
+fb.add_property("layer", vtzero::sint_value_type(2));
+```
+
+You can also call `add_property()` with a single `vtzero::property` argument
+(which is handy if you are copying this property over from a tile you are
+reading):
+
+```cpp
+while (auto property = feature.next_property()) {
+    if (property.key() == "name") {
+        feature_builder.add_property(property);
+    }
+}
+```
+
+### The advanced approach to adding properties
+
+In the advanced approach you have to do the indexing yourself. Here is a very
+basic example:
+
+```cpp
+vtzero::tile_builder tbuilder;
+vtzero::layer_builder lbuilder{tbuilder, "test"};
+const vtzero::index_value highway = lbuilder.add_key("highway");
+const vtzero::index_value primary = lbuilder.add_value("primary");
+...
+vtzero::point_feature_builder fbuilder{lbuilder};
+...
+fbuilder.add_property(highway, primary);
+...
+```
+
+The methods `add_key()` and `add_value()` on the layer builder are used to add
+keys and values to the tables in the layer. They both return the index (of type
+`vtzero::index_value`) of those keys or values in the tables. You store
+those index values somewhere (in this case in the `highway` and `primary`
+variables) and use them when calling `add_property()` on the feature builder.
+
+In some cases you only have a few property keys and know them beforehand,
+then storing the key indexes in individual variables might work. But for
+values this usually doesn't make much sense, and if all your keys and values
+are only known at runtime, it doesn't work either. For this you need some kind
+of index data structure mapping from keys/values to index values. You can
+implement this yourself, but it is easier to use some classes provided by
+vtzero. Then the code looks like this:
+
+```cpp
+#include <vtzero/index.hpp> // use this include to get the index classes
+...
+vtzero::layer_builder lb{...};
+vtzero::key_index<std::map> key_index{lb};
+vtzero::value_index_internal<std::unordered_map> value_index{lb};
+...
+vtzero::point_feature_builder fb{lb};
+...
+fb.add_property(key_index("highway"), value_index("primary"));
+...
+```
+
+In this example the `key_index` template class is used for keys, it uses
+`std::map` internally as can be seen by its template argument. The
+`value_index_internal` template class is used for values, it uses
+`std::unordered_map` internally in this example. Whether you specify `std::map`
+or `std::unordered_map` or something else (that needs to be compatible to those
+classes) is up to you. Benchmark your use case and decide then.
+
+Keys are always strings, so they are easy to handle. For keys there is only the
+single `key_index` in vtzero.
+
+For values this is more difficult. Basically there are two choices:
+
+1. Encode the value according to the vector tile encoding rules which results
+   in a string and store this in the index. This is what the
+   `value_index_internal` class does.
+2. Store the un-encoded value in the index. The index lookup will be faster,
+   but you need a different index type for each value type. This is what the
+   `value_index` classes do.
+
+The `value_index` template classes need three template arguments: The type
+used internally to encode the value, the type used externally, and the map
+type.
+
+In this example the user program has the values as `int`, the index will store
+them in a `std::map<int>`. The integer value is then encoded in an `sint`
+int the vector tile:
+
+```cpp
+vtzero::value_index<vtzero::sint_value:type, int, std::map> index;
+```
+
+Sometimes these generic indexes based on `std::map` or `std::unordered_map`
+are inefficient, that's why there are specialized indexes for special cases:
+
+* The `value_index_bool` class can only index boolean values.
+* The `value_index_small_uint` class can only index small unsigned integer
+  values (up to `uint16_t`). It uses a vector internally, so if all your
+  numbers are small and densely packed, this is very efficient. This is
+  especially useful for `enum` types.
+
+## The `add_property()` function.
+
+The last chapters already talked about the `add_property()` function of the
+`feature_builder` class. But because it is a bit difficult to see all the
+different ways `add_property()` can be called, here is some more information.
+
+The `add_property()` function is called with either two parameters for the
+key and value or with one parameter that combines the key and value.
+
+If it is called with an `index_value` for the key or value, that index value is
+stored directly into the feature. If it is called with an `index_value_pair`,
+the index values in the `index_value_pair` are stored directly in the feature.
+
+If it is called with something that is not an `index_value` or
+`index_value_pair`, the function will interpret the data as keys or values.
+It will add those keys and values to the layer (if they are not already there),
+find the corresponding index values and store them in the feature.
+
+You can mix index-use with non-index use. For instance
+
+```cpp
+index_value key_maxspeed = lbuilder.add_key("maxspeed");
+...
+fbuilder.add_property(key_maxspeed, 30);
+```
+
+In this case the key ("maxspeed") was added to the layer once and its index
+value (`key_maxspeed`) can later be reused. The value (30), on the other hand,
+is only added to the layer in the `add_property()` call.
+
+So for keys, you can have as argument:
+* An `index_value`.
+* A `data_view` or something that converts to it like a `const char*` or `std::string`.
+
+For values, you can have as argument:
+* An `index_value`.
+* A `property_value`.
+* An `encoded_property_value` or anything that converts to it.
+
+For combined keys and values, you can have as argument:
+* An `index_value_pair`.
+* A `property`.
+
+
+## Deriving from `layer_builder` and `feature_builder`
+
+The `vtzero::layer_builder` and `vtzero::feature_builder` classes have been
+designed in a way that they can be derived from easily. This allows you to
+encapsulate part of your vector tile writing code if some aspects of your
+layers/features are always the same, such as the layer name and the names
+and types of properties.
+
+Say you want to write a layer named "restaurants" with point geometries.
+Each feature should have a name and a 5-star-rating. First you create a
+class derived from the `layer_builder` with all the indexes you want to use.
+For the keys you don't need indexes in this case, because there are only
+two keys for which we can easily store the index values in the layer.
+
+```cpp
+class restaurant_layer_builder : public vtzero::layer_builder {
+
+public:
+
+    // The index we'll use for the "name" property values
+    vtzero::value_index<vtzero::string_value_type, std::string, std::unordered_map> string_index;
+
+    // The index we'll use for the "stars" property values
+    vtzero::value_index_small_uint stars_index;
+
+    // The index value of the "name" key
+    vtzero::index_value key_name;
+
+    // The index value of the "stars" key
+    vtzero::index_value key_stars;
+
+    restaurant_layer_builder(vtzero::tile_builder& tile) :
+        layer_builder(tile, "restaurants"), // the name of the layer
+        string_index(*this),
+        stars_index(*this),
+        key_name(add_key_without_dup_check("name")),
+        key_stars(add_key_without_dup_check("stars")) {
+    }
+
+};
+```
+
+The we'll add a class derived from `feature_builder` to help with adding
+features:
+
+```cpp
+class restaurant_feature_builder : public vtzero::feature_builder {
+
+    restaurant_layer_builder& m_layer;
+
+public:
+
+    restaurant_feature_builder(restaurant_layer_builder& layer, uint64_t id) :
+        vtzero::point_feature_builder(layer), // always a point geometry
+        m_layer(layer) {
+        set_id(id); // we always have an ID in this case
+    }
+
+    void add_location(mylocation& loc) { // restaurant location is stored in your own type
+        add_point(loc.lon(), loc.lat());
+    }
+
+    void set_name(const std::string& name) {
+        add_property(m_layer.key_name,
+                     m_layer.string_index(vtzero::encoded_property_value{name}));
+    }
+
+    void set_stars(stars s) { // your own "stars" type
+        vtzero::encoded_property_value svalue{ s.num_stars() }; // convert stars type to small integer
+
+        add_property(m_layer.key_stars,
+                     m_layer.stars_index(svalue));
+    }
+
+};
+```
+
+This example only shows a general pattern you can follow to derive from the
+`layer_builder` and `feature_builder` classes. In some cases this makes more
+sense then in others. The derived classes make it easy for you to mix your
+own functions (for instance when you need to convert from your own types to
+vtzero types like with the `mylocation` and `stars` types above) or just use
+the functions in the base classes.
+
diff --git a/third_party/vtzero/examples/CMakeLists.txt b/third_party/vtzero/examples/CMakeLists.txt
new file mode 100644
index 00000000000..756884903c3
--- /dev/null
+++ b/third_party/vtzero/examples/CMakeLists.txt
@@ -0,0 +1,88 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake config
+#
+#  vtzero examples
+#
+#-----------------------------------------------------------------------------
+
+include_directories(SYSTEM "${CMAKE_SOURCE_DIR}/include-external")
+
+set(TEST_FILE "${CMAKE_SOURCE_DIR}/test/data/mapbox-streets-v6-14-8714-8017.mvt")
+
+add_executable(vtzero-check vtzero-check.cpp utils.cpp)
+
+add_executable(vtzero-create vtzero-create.cpp utils.cpp)
+
+add_executable(vtzero-encode-geom vtzero-encode-geom.cpp utils.cpp)
+
+add_executable(vtzero-stats vtzero-stats.cpp utils.cpp)
+
+add_executable(vtzero-streets vtzero-streets.cpp utils.cpp)
+
+#-------------------------------------------------------------
+
+add_executable(vtzero-filter vtzero-filter.cpp utils.cpp)
+
+add_test(NAME vtzero-filter-empty
+            COMMAND vtzero-filter)
+set_tests_properties(vtzero-filter-empty PROPERTIES
+                        PASS_REGULAR_EXPRESSION "^Error in command line: Missing file name of vector tile to read")
+
+add_test(NAME vtzero-filter-help
+            COMMAND vtzero-filter -h)
+set_tests_properties(vtzero-filter-help PROPERTIES
+                        PASS_REGULAR_EXPRESSION "^usage:\n  vtzero-filter")
+
+add_test(NAME vtzero-filter-layer
+            COMMAND vtzero-filter -o ${CMAKE_CURRENT_BINARY_DIR}/bridges.mvt ${TEST_FILE} bridge)
+
+add_test(NAME vtzero-filter-feature
+            COMMAND vtzero-filter -o ${CMAKE_CURRENT_BINARY_DIR}/bridges.mvt ${TEST_FILE} waterway_label 221925711)
+
+add_test(NAME vtzero-filter-invalid-id
+            COMMAND vtzero-filter -o ${CMAKE_CURRENT_BINARY_DIR}/bridges.mvt ${TEST_FILE} waterway_label abc)
+set_tests_properties(vtzero-filter-invalid-id PROPERTIES
+                        WILL_FAIL true)
+
+#-------------------------------------------------------------
+
+add_executable(vtzero-show vtzero-show.cpp utils.cpp)
+
+add_test(NAME vtzero-show-empty
+            COMMAND vtzero-show)
+set_tests_properties(vtzero-show-empty PROPERTIES
+                        PASS_REGULAR_EXPRESSION "^Error in command line: Missing file name of vector tile to read")
+
+add_test(NAME vtzero-show-help
+            COMMAND vtzero-show -h)
+set_tests_properties(vtzero-show-help PROPERTIES
+                        PASS_REGULAR_EXPRESSION "^usage:\n  vtzero-show")
+
+add_test(NAME vtzero-show-layers
+            COMMAND vtzero-show -l ${TEST_FILE})
+set_tests_properties(vtzero-show-layers PROPERTIES
+                        PASS_REGULAR_EXPRESSION "^landuse 78\nwaterway 327\n.*\nwaterway_label 4\n$")
+
+add_test(NAME vtzero-show-layer-num
+            COMMAND vtzero-show ${TEST_FILE} 2)
+set_tests_properties(vtzero-show-layer-num PROPERTIES
+                        PASS_REGULAR_EXPRESSION "layer: [0-9]+\n  name: water\n")
+
+add_test(NAME vtzero-show-layer-name
+            COMMAND vtzero-show ${CMAKE_SOURCE_DIR}/test/data/mapbox-streets-v6-14-8714-8017.mvt water)
+set_tests_properties(vtzero-show-layer-name PROPERTIES
+                        PASS_REGULAR_EXPRESSION "layer: [0-9]+\n  name: water\n")
+
+#-------------------------------------------------------------
+
+file(GLOB ext_tests RELATIVE ${CMAKE_SOURCE_DIR}/test/data/ ${CMAKE_SOURCE_DIR}/test/data/*.mvt)
+
+foreach(_test IN LISTS ext_tests)
+    message(STATUS "Adding ext test: ${_test}")
+    add_test(NAME ext-tests-${_test}
+             COMMAND vtzero-show ${CMAKE_SOURCE_DIR}/test/data/${_test})
+endforeach()
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/vtzero/examples/utils.cpp b/third_party/vtzero/examples/utils.cpp
new file mode 100644
index 00000000000..f0fb9338604
--- /dev/null
+++ b/third_party/vtzero/examples/utils.cpp
@@ -0,0 +1,100 @@
+/*****************************************************************************
+
+  Utility functions for vtzero example programs.
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+/**
+ * Read complete contents of a file into a string.
+ *
+ * The file is read in binary mode.
+ *
+ * @param filename The file name. Can be empty or "-" to read from STDIN.
+ * @returns a string with the contents of the file.
+ * @throws various exceptions if there is an error
+ */
+std::string read_file(const std::string& filename) {
+    if (filename.empty() || (filename.size() == 1 && filename[0] == '-')) {
+        return std::string{std::istreambuf_iterator<char>(std::cin.rdbuf()),
+                           std::istreambuf_iterator<char>()};
+    }
+
+    std::ifstream stream{filename, std::ios_base::in | std::ios_base::binary};
+    if (!stream) {
+        throw std::runtime_error{std::string{"Can not open file '"} + filename + "'"};
+    }
+
+    stream.exceptions(std::ifstream::failbit);
+
+    std::string buffer{std::istreambuf_iterator<char>(stream.rdbuf()),
+                       std::istreambuf_iterator<char>()};
+    stream.close();
+
+    return buffer;
+}
+
+/**
+ * Write contents of a buffer into a file.
+ *
+ * The file is written in binary mode.
+ *
+ * @param buffer The data to be written.
+ * @param filename The file name.
+ * @throws various exceptions if there is an error
+ */
+void write_data_to_file(const std::string& buffer, const std::string& filename) {
+    std::ofstream stream{filename, std::ios_base::out | std::ios_base::binary};
+    if (!stream) {
+        throw std::runtime_error{std::string{"Can not open file '"} + filename + "'"};
+    }
+
+    stream.exceptions(std::ifstream::failbit);
+
+    stream.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
+
+    stream.close();
+}
+
+/**
+ * Get a specific layer from a vector tile. The layer can be specified as a
+ * number n in which case the nth layer in this tile is returned. Or it can
+ * be specified as text, in which case the layer with that name is returned.
+ *
+ * Calls exit(1) if there is an error.
+ *
+ * @param tile The vector tile.
+ * @param layer_name_or_num specifies the layer.
+ */
+vtzero::layer get_layer(const vtzero::vector_tile& tile, const std::string& layer_name_or_num) {
+    vtzero::layer layer;
+    char* str_end = nullptr;
+    const long num = std::strtol(layer_name_or_num.c_str(), &str_end, 10); // NOLINT(google-runtime-int)
+
+    if (str_end == layer_name_or_num.data() + layer_name_or_num.size()) {
+        if (num >= 0 && num < std::numeric_limits<long>::max()) { // NOLINT(google-runtime-int)
+            layer = tile.get_layer(static_cast<std::size_t>(num));
+            if (!layer) {
+                std::cerr << "No such layer: " << num << '\n';
+                std::exit(1);
+            }
+            return layer;
+        }
+    }
+
+    layer = tile.get_layer_by_name(layer_name_or_num);
+    if (!layer) {
+        std::cerr << "No layer named '" << layer_name_or_num << "'.\n";
+        std::exit(1);
+    }
+    return layer;
+}
+
diff --git a/third_party/vtzero/examples/utils.hpp b/third_party/vtzero/examples/utils.hpp
new file mode 100644
index 00000000000..3f33a40535c
--- /dev/null
+++ b/third_party/vtzero/examples/utils.hpp
@@ -0,0 +1,11 @@
+
+#include <vtzero/vector_tile.hpp>
+
+#include <string>
+
+std::string read_file(const std::string& filename);
+
+void write_data_to_file(const std::string& buffer, const std::string& filename);
+
+vtzero::layer get_layer(const vtzero::vector_tile& tile, const std::string& layer_name_or_num);
+
diff --git a/third_party/vtzero/examples/vtzero-check.cpp b/third_party/vtzero/examples/vtzero-check.cpp
new file mode 100644
index 00000000000..2e01f26509f
--- /dev/null
+++ b/third_party/vtzero/examples/vtzero-check.cpp
@@ -0,0 +1,225 @@
+/*****************************************************************************
+
+  Example program for vtzero library.
+
+  vtzero-check - Check vector tiles for validity
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <vtzero/vector_tile.hpp>
+
+#include <iostream>
+#include <set>
+#include <stdexcept>
+#include <string>
+
+class result {
+
+    int m_return_code = 0;
+
+public:
+
+    void has_warning() noexcept {
+        if (m_return_code < 1) {
+            m_return_code = 1;
+        }
+    }
+
+    void has_error() noexcept {
+        if (m_return_code < 2) {
+            m_return_code = 2;
+        }
+    }
+
+    void has_fatal_error() noexcept {
+        if (m_return_code < 3) {
+            m_return_code = 3;
+        }
+    }
+
+    int return_code() const noexcept {
+        return m_return_code;
+    }
+
+} result;
+
+class CheckGeomHandler {
+
+    vtzero::point m_prev_point{};
+    int m_layer_num;
+    int m_feature_num;
+    int64_t m_extent;
+    bool m_is_first_point = false;
+    int m_count = 0;
+
+    void print_context() const {
+        std::cerr << " in layer " << m_layer_num
+                  << " in feature " << m_feature_num
+                  << " in geometry " << m_count
+                  << ": ";
+    }
+
+    void print_error(const char* message) const {
+        result.has_error();
+        std::cerr << "Error";
+        print_context();
+        std::cerr << message << '\n';
+    }
+
+    void print_warning(const char* message) const {
+        result.has_warning();
+        std::cerr << "Warning";
+        print_context();
+        std::cerr << message << '\n';
+    }
+
+    void check_point_location(const vtzero::point point) const {
+        if (point.x < -m_extent ||
+            point.y < -m_extent ||
+            point.x > 2 * m_extent ||
+            point.y > 2 * m_extent) {
+            print_warning("point waaaay beyond the extent");
+        }
+    }
+
+public:
+
+    CheckGeomHandler(uint32_t extent, int layer_num, int feature_num) :
+        m_layer_num(layer_num),
+        m_feature_num(feature_num),
+        m_extent(static_cast<int64_t>(extent)) {
+    }
+
+    // ----------------------------------------------------------------------
+
+    void points_begin(const uint32_t /*count*/) const {
+    }
+
+    void points_point(const vtzero::point point) const {
+        check_point_location(point);
+    }
+
+    void points_end() const {
+    }
+
+    // ----------------------------------------------------------------------
+
+    void linestring_begin(const uint32_t count) {
+        if (count < 2) {
+            print_error("Not enough points in linestring");
+        }
+        m_is_first_point = true;
+    }
+
+    void linestring_point(const vtzero::point point) {
+        if (m_is_first_point) {
+            m_is_first_point = false;
+        } else {
+            if (point == m_prev_point) {
+                print_error("Duplicate point in linestring");
+            }
+        }
+        m_prev_point = point;
+
+        check_point_location(point);
+    }
+
+    void linestring_end() {
+        ++m_count;
+    }
+
+    // ----------------------------------------------------------------------
+
+    void ring_begin(const uint32_t count) {
+        if (count < 4) {
+            print_error("Not enough points in ring");
+        }
+        m_is_first_point = true;
+    }
+
+    void ring_point(const vtzero::point point) {
+        if (m_is_first_point) {
+            m_is_first_point = false;
+        } else {
+            if (point == m_prev_point) {
+                print_error("Duplicate point in ring");
+            }
+        }
+        m_prev_point = point;
+
+        check_point_location(point);
+    }
+
+    void ring_end(const vtzero::ring_type rt) {
+        if (rt == vtzero::ring_type::invalid) {
+            print_error("Invalid ring with area 0");
+        }
+        if (m_count == 0 && rt != vtzero::ring_type::outer) {
+            print_error("First ring isn't an outer ring");
+        }
+        ++m_count;
+    }
+
+}; // class CheckGeomHandler
+
+int main(int argc, char* argv[]) {
+    if (argc != 2) {
+        std::cerr << "Usage: " << argv[0] << " TILE\n";
+        return 1;
+    }
+
+    std::string input_file{argv[1]};
+    const auto data = read_file(input_file);
+
+    std::set<std::string> layer_names;
+
+    vtzero::vector_tile tile{data};
+
+    int layer_num = 0;
+    int feature_num = -1;
+    try {
+        while (auto layer = tile.next_layer()) {
+            if (layer.name().empty()) {
+                std::cerr << "Error in layer " << layer_num << ": name is empty (spec 4.1)\n";
+                result.has_error();
+            }
+
+            std::string name(layer.name());
+            if (layer_names.count(name) > 0) {
+                std::cerr << "Error in layer " << layer_num << ": name is duplicate of previous layer ('" << name << "') (spec 4.1)\n";
+                result.has_error();
+            }
+
+            layer_names.insert(name);
+
+            feature_num = 0;
+            while (auto feature = layer.next_feature()) {
+                CheckGeomHandler handler{layer.extent(), layer_num, feature_num};
+                vtzero::decode_geometry(feature.geometry(), handler);
+                ++feature_num;
+            }
+            if (feature_num == 0) {
+                std::cerr << "Warning: No features in layer " << layer_num << " (spec 4.1)\n";
+                result.has_warning();
+            }
+            feature_num = -1;
+            ++layer_num;
+        }
+        if (layer_num == 0) {
+            std::cerr << "Warning: No layers in vector tile (spec 4.1)\n";
+            result.has_warning();
+        }
+    } catch (const std::exception& e) {
+        std::cerr << "Fatal error in layer " << layer_num;
+        if (feature_num >= 0) {
+            std::cerr << " in feature " << feature_num;
+        }
+        std::cerr << ": " << e.what() << '\n';
+        result.has_fatal_error();
+    }
+
+    return result.return_code();
+}
+
diff --git a/third_party/vtzero/examples/vtzero-create.cpp b/third_party/vtzero/examples/vtzero-create.cpp
new file mode 100644
index 00000000000..6507ff6fb4e
--- /dev/null
+++ b/third_party/vtzero/examples/vtzero-create.cpp
@@ -0,0 +1,101 @@
+/*****************************************************************************
+
+  Example program for vtzero library.
+
+  vtzero-create - Create a vector tile
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <vtzero/builder.hpp>
+#include <vtzero/index.hpp>
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+int main() {
+    vtzero::tile_builder tile;
+    vtzero::layer_builder layer_points{tile, "points"};
+    vtzero::layer_builder layer_lines{tile, "lines"};
+    vtzero::layer_builder layer_polygons{tile, "polygons"};
+
+    vtzero::key_index<std::unordered_map> idx{layer_points};
+
+    {
+        vtzero::point_feature_builder feature{layer_points};
+        feature.set_id(1);
+        feature.add_points(1);
+        feature.set_point(10, 10);
+        feature.add_property("foo", "bar");
+        feature.add_property("x", "y");
+        feature.rollback();
+    }
+
+    const auto some = idx("some");
+
+    {
+        vtzero::point_feature_builder feature{layer_points};
+        feature.set_id(2);
+        feature.add_point(20, 20);
+        feature.add_property(some, "attr");
+    }
+    {
+        vtzero::point_feature_builder feature{layer_points};
+        feature.set_id(3);
+        feature.add_point(20, 20);
+        feature.add_property(idx("some"), "attr");
+    }
+
+    {
+        vtzero::point_feature_builder feature{layer_points};
+        feature.set_id(4);
+        feature.add_point(20, 20);
+        feature.add_property(idx("some"), "otherattr");
+    }
+
+
+    vtzero::point_feature_builder feature1{layer_points};
+    feature1.set_id(5);
+    feature1.add_point(vtzero::point{20, 20});
+    feature1.add_property("otherkey", "attr");
+    feature1.commit();
+
+    vtzero::value_index<vtzero::sint_value_type, int32_t, std::unordered_map> maxspeed_index{layer_lines};
+    {
+        vtzero::linestring_feature_builder feature{layer_lines};
+        feature.set_id(6);
+        feature.add_linestring(3);
+        feature.set_point(10, 10);
+        feature.set_point(10, 20);
+        feature.set_point(vtzero::point{20, 20});
+        std::vector<vtzero::point> points = {{11, 11}, {12, 13}};
+        feature.add_linestring_from_container(points);
+        feature.add_property("highway", "primary");
+        feature.add_property(std::string{"maxspeed"}, maxspeed_index(50));
+    }
+
+    {
+        vtzero::polygon_feature_builder feature{layer_polygons};
+        feature.set_id(7);
+        feature.add_ring(5);
+        feature.set_point(0, 0);
+        feature.set_point(10, 0);
+        feature.set_point(10, 10);
+        feature.set_point(0, 10);
+        feature.set_point(0, 0);
+        feature.add_ring(4);
+        feature.set_point(3, 3);
+        feature.set_point(3, 5);
+        feature.set_point(5, 5);
+        feature.close_ring();
+        feature.add_property("natural", "wood");
+        feature.add_property("number_of_trees", vtzero::sint_value_type{23402752});
+    }
+
+    const auto data = tile.serialize();
+    write_data_to_file(data, "test.mvt");
+}
+
diff --git a/third_party/vtzero/examples/vtzero-encode-geom.cpp b/third_party/vtzero/examples/vtzero-encode-geom.cpp
new file mode 100644
index 00000000000..fa7d7840bc8
--- /dev/null
+++ b/third_party/vtzero/examples/vtzero-encode-geom.cpp
@@ -0,0 +1,142 @@
+/*****************************************************************************
+
+  Example program for vtzero library.
+
+  vtzero-encode-geom - Encode geometry on command line
+
+  This can be used for debugging. Uses internals of vtzero!
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <vtzero/geometry.hpp>
+
+#include <cctype>
+#include <cstdlib>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+int64_t get_int(const char* arg) {
+    char* endptr = nullptr;
+    const int64_t value = std::strtoll(arg, &endptr, 10);
+
+    if (*endptr == '\0') {
+        return value;
+    }
+
+    throw std::runtime_error{"not a valid number"};
+}
+
+uint32_t move_to(const char* arg) {
+    if (!std::isdigit(arg[0])) {
+        throw std::runtime_error{"need count after M command"};
+    }
+
+    const auto scount = get_int(arg);
+    if (scount <= 0) {
+        throw std::runtime_error{"count after M command must be 1 or larger"};
+    }
+    const auto count = static_cast<uint32_t>(scount);
+    std::cout << "MOVE_TO(" << count << ")\t" << vtzero::detail::command_move_to(count) << '\n';
+
+    return vtzero::detail::command_move_to(count);
+}
+
+uint32_t line_to(const char* arg) {
+    if (!std::isdigit(arg[0])) {
+        throw std::runtime_error{"need count after L command"};
+    }
+
+    const auto scount = get_int(arg);
+    if (scount <= 0) {
+        throw std::runtime_error{"count after L command must be 1 or larger"};
+    }
+    const auto count = static_cast<uint32_t>(scount);
+    std::cout << "LINE_TO(" << count << ")\t" << vtzero::detail::command_line_to(count) << '\n';
+
+    return vtzero::detail::command_line_to(count);
+}
+
+uint32_t close_path(const char* arg) {
+    if (arg[0] != '\0') {
+        throw std::runtime_error{"extra data after C command"};
+    }
+    std::cout << "CLOSE_PATH\t" << vtzero::detail::command_close_path() << '\n';
+
+    return vtzero::detail::command_close_path();
+}
+
+uint32_t number(const char* arg) {
+    const auto num = static_cast<int32_t>(get_int(arg));
+    std::cout << "number(" << num << ")\t" << protozero::encode_zigzag32(num) << '\n';
+
+    return protozero::encode_zigzag32(num);
+}
+
+int main(int argc, char* argv[]) {
+    if (argc < 2) {
+        std::cerr << "Usage: " << argv[0] << " GEOMETRY ELEMENTS...\n"
+                  << "GEOMETRY ELEMENTS are:\n"
+                  << "  M[count] -- MOVE_TO count\n"
+                  << "  L[count] -- LINE_TO count\n"
+                  << "  C        -- CLOSE_PATH\n"
+                  << "  [number] -- number that will be zigzag encoded\n";
+        return 1;
+    }
+
+    std::vector<uint32_t> values;
+
+    std::cout << "raw data\tencoded\n-----------------------------------\n";
+    for (int i = 1; i < argc; ++i) {
+        try {
+            switch (argv[i][0]) {
+                case '\0':
+                    break;
+                case 'M':
+                    values.push_back(move_to(argv[i] + 1));
+                    break;
+                case 'L':
+                    values.push_back(line_to(argv[i] + 1));
+                    break;
+                case 'C':
+                    values.push_back(close_path(argv[i] + 1));
+                    break;
+                case '-':
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    values.push_back(number(argv[i]));
+                    break;
+                default:
+                    throw std::runtime_error{std::string{"unknown data: "} + argv[i]};
+                    return 1;
+            }
+        } catch (const std::runtime_error& e) {
+            std::cerr << "error(" << i << "): " << e.what() << '\n';
+            return 1;
+        }
+    }
+
+    std::string out{"["};
+
+    for (auto value : values) {
+        out += ' ';
+        out += std::to_string(value);
+        out += ',';
+    }
+
+    out.back() = ' ';
+
+    std::cout << '\n' << out << "]\n";
+}
+
diff --git a/third_party/vtzero/examples/vtzero-filter.cpp b/third_party/vtzero/examples/vtzero-filter.cpp
new file mode 100644
index 00000000000..b0ec6c24b30
--- /dev/null
+++ b/third_party/vtzero/examples/vtzero-filter.cpp
@@ -0,0 +1,101 @@
+/*****************************************************************************
+
+  Example program for vtzero library.
+
+  vtzero-filter - Copy parts of a vector tile into a new tile.
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <vtzero/builder.hpp>
+#include <vtzero/vector_tile.hpp>
+
+#include <clara.hpp>
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <limits>
+#include <string>
+
+int main(int argc, char* argv[]) {
+    std::string filename;
+    std::string layer_num_or_name;
+    std::string idstr;
+    std::string output_file{"filtered.mvt"};
+
+    bool help = false;
+
+    const auto cli
+        = clara::Opt(output_file, "FILE")
+            ["-o"]["--output"]
+            ("write output to FILE")
+        | clara::Help(help)
+        | clara::Arg(filename, "FILENAME").required()
+            ("vector tile")
+        | clara::Arg(layer_num_or_name, "LAYER-NUM|LAYER-NAME").required()
+            ("layer")
+        | clara::Arg(idstr, "ID")
+            ("feature_id");
+
+    const auto result = cli.parse(clara::Args(argc, argv));
+    if (!result) {
+        std::cerr << "Error in command line: " << result.errorMessage() << '\n';
+        return 1;
+    }
+
+    if (help) {
+        std::cout << cli
+                  << "\nFilter contents of vector tile.\n";
+        return 0;
+    }
+
+    if (filename.empty()) {
+        std::cerr << "Error in command line: Missing file name of vector tile to read\n";
+        return 1;
+    }
+
+    if (layer_num_or_name.empty()) {
+        std::cerr << "Error in command line: Missing layer number or name\n";
+        return 1;
+    }
+
+    const auto data = read_file(filename);
+    vtzero::vector_tile tile{data};
+
+    auto layer = get_layer(tile, layer_num_or_name);
+    std::cerr << "Found layer: " << std::string(layer.name()) << "\n";
+
+    vtzero::tile_builder tb;
+
+    if (idstr.empty()) {
+        tb.add_existing_layer(layer);
+    } else {
+        char* str_end = nullptr;
+        const int64_t id = std::strtoll(idstr.c_str(), &str_end, 10);
+        if (str_end != idstr.c_str() + idstr.size()) {
+            std::cerr << "Feature ID must be numeric.\n";
+            return 1;
+        }
+        if (id < 0) {
+            std::cerr << "Feature ID must be >= 0.\n";
+            return 1;
+        }
+
+        const auto feature = layer.get_feature_by_id(static_cast<uint64_t>(id));
+        if (!feature.valid()) {
+            std::cerr << "No feature with that id: " << id << '\n';
+            return 1;
+        }
+
+        vtzero::layer_builder layer_builder{tb, layer};
+        layer_builder.add_feature(feature);
+    }
+
+    std::string output = tb.serialize();
+
+    write_data_to_file(output, output_file);
+}
+
diff --git a/third_party/vtzero/examples/vtzero-show.cpp b/third_party/vtzero/examples/vtzero-show.cpp
new file mode 100644
index 00000000000..030fe0f8c2c
--- /dev/null
+++ b/third_party/vtzero/examples/vtzero-show.cpp
@@ -0,0 +1,242 @@
+/*****************************************************************************
+
+  Example program for vtzero library.
+
+  vtzero-show - Show content of vector tile
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <vtzero/vector_tile.hpp>
+
+#include <clara.hpp>
+
+#include <cstdint>
+#include <exception>
+#include <iostream>
+#include <string>
+
+class geom_handler {
+
+    std::string output{};
+
+public:
+
+    void points_begin(const uint32_t /*count*/) const noexcept {
+    }
+
+    void points_point(const vtzero::point point) const {
+        std::cout << "      POINT(" << point.x << ',' << point.y << ")\n";
+    }
+
+    void points_end() const noexcept {
+    }
+
+    void linestring_begin(const uint32_t count) {
+        output = "      LINESTRING[count=";
+        output += std::to_string(count);
+        output += "](";
+    }
+
+    void linestring_point(const vtzero::point point) {
+        output += std::to_string(point.x);
+        output += ' ';
+        output += std::to_string(point.y);
+        output += ',';
+    }
+
+    void linestring_end() {
+        if (output.empty()) {
+            return;
+        }
+        if (output.back() == ',') {
+            output.resize(output.size() - 1);
+        }
+        output += ")\n";
+        std::cout << output;
+    }
+
+    void ring_begin(const uint32_t count) {
+        output = "      RING[count=";
+        output += std::to_string(count);
+        output += "](";
+    }
+
+    void ring_point(const vtzero::point point) {
+        output += std::to_string(point.x);
+        output += ' ';
+        output += std::to_string(point.y);
+        output += ',';
+    }
+
+    void ring_end(const vtzero::ring_type rt) {
+        if (output.empty()) {
+            return;
+        }
+        if (output.back() == ',') {
+            output.back() = ')';
+        }
+        switch (rt) {
+            case vtzero::ring_type::outer:
+                output += "[OUTER]\n";
+                break;
+            case vtzero::ring_type::inner:
+                output += "[INNER]\n";
+                break;
+            default:
+                output += "[INVALID]\n";
+        }
+        std::cout << output;
+    }
+
+}; // class geom_handler
+
+template <typename TChar, typename TTraits>
+std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, vtzero::data_view value) {
+    out.write(value.data(), static_cast<std::streamsize>(value.size()));
+    return out;
+}
+
+struct print_value {
+
+    template <typename T>
+    void operator()(T value) const {
+        std::cout << value;
+    }
+
+    void operator()(const vtzero::data_view value) const {
+        std::cout << '"' << value << '"';
+    }
+
+}; // struct print_value
+
+static void print_layer(vtzero::layer& layer, bool print_tables, bool print_value_types, int& layer_num, int& feature_num) {
+    std::cout << "=============================================================\n"
+              << "layer: " << layer_num << '\n'
+              << "  name: " << std::string(layer.name()) << '\n'
+              << "  version: " << layer.version() << '\n'
+              << "  extent: " << layer.extent() << '\n';
+
+    if (print_tables) {
+        std::cout << "  keys:\n";
+        int n = 0;
+        for (const auto& key : layer.key_table()) {
+            std::cout << "    " << n++ << ": " << key << '\n';
+        }
+        std::cout << "  values:\n";
+        n = 0;
+        for (const vtzero::property_value& value : layer.value_table()) {
+            std::cout << "    " << n++ << ": ";
+            vtzero::apply_visitor(print_value{}, value);
+            if (print_value_types) {
+                std::cout << " [" << vtzero::property_value_type_name(value.type()) << "]\n";
+            } else {
+                std::cout << '\n';
+            }
+        }
+    }
+
+    feature_num = 0;
+    while (auto feature = layer.next_feature()) {
+        std::cout << "  feature: " << feature_num << '\n'
+                  << "    id: ";
+        if (feature.has_id()) {
+            std::cout << feature.id() << '\n';
+        } else {
+            std::cout << "(none)\n";
+        }
+        std::cout << "    geomtype: " << vtzero::geom_type_name(feature.geometry_type()) << '\n'
+                  << "    geometry:\n";
+        vtzero::decode_geometry(feature.geometry(), geom_handler{});
+        std::cout << "    properties:\n";
+        while (auto property = feature.next_property()) {
+            std::cout << "      " << property.key() << '=';
+            vtzero::apply_visitor(print_value{}, property.value());
+            if (print_value_types) {
+                std::cout << " [" << vtzero::property_value_type_name(property.value().type()) << "]\n";
+            } else {
+                std::cout << '\n';
+            }
+        }
+        ++feature_num;
+    }
+}
+
+static void print_layer_overview(const vtzero::layer& layer) {
+    std::cout << layer.name() << ' ' << layer.num_features() << '\n';
+}
+
+int main(int argc, char* argv[]) {
+    std::string filename;
+    std::string layer_num_or_name;
+    bool layer_overview = false;
+    bool print_tables = false;
+    bool print_value_types = false;
+    bool help = false;
+
+    const auto cli
+        = clara::Opt(layer_overview)
+            ["-l"]["--layers"]
+            ("show layer overview with feature count")
+        | clara::Opt(print_tables)
+            ["-t"]["--tables"]
+            ("also print key/value tables")
+        | clara::Opt(print_value_types)
+            ["-T"]["--value-types"]
+            ("also show value types")
+        | clara::Help(help)
+        | clara::Arg(filename, "FILENAME").required()
+            ("vector tile")
+        | clara::Arg(layer_num_or_name, "LAYER-NUM|LAYER-NAME")
+            ("layer");
+
+    const auto result = cli.parse(clara::Args(argc, argv));
+    if (!result) {
+        std::cerr << "Error in command line: " << result.errorMessage() << '\n';
+        return 1;
+    }
+
+    if (help) {
+        std::cout << cli
+                  << "\nShow contents of vector tile FILENAME.\n";
+        return 0;
+    }
+
+    if (filename.empty()) {
+        std::cerr << "Error in command line: Missing file name of vector tile to read\n";
+        return 1;
+    }
+
+    int layer_num = 0;
+    int feature_num = 0;
+    try {
+        const auto data = read_file(filename);
+
+        vtzero::vector_tile tile{data};
+
+        if (layer_num_or_name.empty()) {
+            while (auto layer = tile.next_layer()) {
+                if (layer_overview) {
+                    print_layer_overview(layer);
+                } else {
+                    print_layer(layer, print_tables, print_value_types, layer_num, feature_num);
+                }
+                ++layer_num;
+            }
+        } else {
+            auto layer = get_layer(tile, layer_num_or_name);
+            if (layer_overview) {
+                print_layer_overview(layer);
+            } else {
+                print_layer(layer, print_tables, print_value_types, layer_num, feature_num);
+            }
+        }
+    } catch (const std::exception& e) {
+        std::cerr << "Error in layer " << layer_num << " (feature " << feature_num << "): " << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
+}
+
diff --git a/third_party/vtzero/examples/vtzero-stats.cpp b/third_party/vtzero/examples/vtzero-stats.cpp
new file mode 100644
index 00000000000..bef3173f564
--- /dev/null
+++ b/third_party/vtzero/examples/vtzero-stats.cpp
@@ -0,0 +1,36 @@
+/*****************************************************************************
+
+  Example program for vtzero library.
+
+  vtzero-stats - Output some stats on layers
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <vtzero/vector_tile.hpp>
+
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+int main(int argc, char* argv[]) {
+    if (argc != 2) {
+        std::cerr << "Usage: " << argv[0] << " TILE\n";
+        return 1;
+    }
+
+    std::string input_file{argv[1]};
+    const auto data = read_file(input_file);
+
+    vtzero::vector_tile tile{data};
+
+    while (const auto layer = tile.next_layer()) {
+        std::cout.write(layer.name().data(), static_cast<std::streamsize>(layer.name().size()));
+        std::cout << ' '
+                  << layer.num_features() << ' '
+                  << layer.key_table().size() << ' '
+                  << layer.value_table().size() << '\n';
+    }
+}
+
diff --git a/third_party/vtzero/examples/vtzero-streets.cpp b/third_party/vtzero/examples/vtzero-streets.cpp
new file mode 100644
index 00000000000..0406f1d4456
--- /dev/null
+++ b/third_party/vtzero/examples/vtzero-streets.cpp
@@ -0,0 +1,79 @@
+/*****************************************************************************
+
+  Example program for vtzero library.
+
+  vtzero-streets - Copy features from road_label layer if they have property
+                   class="street". Output is always in file "streets.mvt".
+
+*****************************************************************************/
+
+#include "utils.hpp"
+
+#include <vtzero/builder.hpp>
+#include <vtzero/property_mapper.hpp>
+#include <vtzero/vector_tile.hpp>
+
+#include <iostream>
+#include <string>
+
+static bool keep_feature(const vtzero::feature& feature) {
+    static const std::string key{"class"};
+    static const std::string val{"street"};
+
+    bool found = false;
+
+    feature.for_each_property([&](const vtzero::property& prop) {
+        found = key == prop.key() && val == prop.value().string_value();
+        return !found;
+    });
+
+    return found;
+}
+
+int main(int argc, char* argv[]) {
+    if (argc != 2) {
+        std::cerr << "Usage: " << argv[0] << " TILE\n";
+        return 1;
+    }
+
+    std::string input_file{argv[1]};
+    std::string output_file{"streets.mvt"};
+
+    const auto data = read_file(input_file);
+
+    try {
+        vtzero::vector_tile tile{data};
+
+        auto layer = get_layer(tile, "road_label");
+        if (!layer) {
+            std::cerr << "No 'road_label' layer found\n";
+            return 1;
+        }
+
+        vtzero::tile_builder tb;
+        vtzero::layer_builder layer_builder{tb, layer};
+
+        vtzero::property_mapper mapper{layer, layer_builder};
+
+        while (auto feature = layer.next_feature()) {
+            if (keep_feature(feature)) {
+                vtzero::geometry_feature_builder feature_builder{layer_builder};
+                if (feature.has_id()) {
+                    feature_builder.set_id(feature.id());
+                }
+                feature_builder.set_geometry(feature.geometry());
+
+                while (auto idxs = feature.next_property_indexes()) {
+                    feature_builder.add_property(mapper(idxs));
+                }
+            }
+        }
+
+        std::string output = tb.serialize();
+        write_data_to_file(output, output_file);
+    } catch (const std::exception& e) {
+        std::cerr << "Error: " << e.what() << '\n';
+        return 1;
+    }
+}
+
diff --git a/third_party/vtzero/include-external/clara.hpp b/third_party/vtzero/include-external/clara.hpp
new file mode 100644
index 00000000000..9a60c1740ea
--- /dev/null
+++ b/third_party/vtzero/include-external/clara.hpp
@@ -0,0 +1,1239 @@
+// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See https://github.com/philsquared/Clara for more details
+
+// Clara v1.1.2
+
+#ifndef CLARA_HPP_INCLUDED
+#define CLARA_HPP_INCLUDED
+
+#ifndef CLARA_CONFIG_CONSOLE_WIDTH
+#define CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#ifndef CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+// ----------- #included from clara_textflow.hpp -----------
+
+// TextFlowCpp
+//
+// A single-header library for wrapping and laying out basic text, by Phil Nash
+//
+// This work is licensed under the BSD 2-Clause license.
+// See the accompanying LICENSE file, or the one at https://opensource.org/licenses/BSD-2-Clause
+//
+// This project is hosted at https://github.com/philsquared/textflowcpp
+
+#ifndef CLARA_TEXTFLOW_HPP_INCLUDED
+#define CLARA_TEXTFLOW_HPP_INCLUDED
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
+
+#ifndef CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+
+namespace clara { namespace TextFlow {
+
+    inline auto isWhitespace( char c ) -> bool {
+        static std::string chars = " \t\n\r";
+        return chars.find( c ) != std::string::npos;
+    }
+    inline auto isBreakableBefore( char c ) -> bool {
+        static std::string chars = "[({<|";
+        return chars.find( c ) != std::string::npos;
+    }
+    inline auto isBreakableAfter( char c ) -> bool {
+        static std::string chars = "])}>.,:;*+-=&/\\";
+        return chars.find( c ) != std::string::npos;
+    }
+
+    class Columns;
+
+    class Column {
+        std::vector<std::string> m_strings;
+        size_t m_width = CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+        size_t m_indent = 0;
+        size_t m_initialIndent = std::string::npos;
+
+    public:
+        class iterator {
+            friend Column;
+
+            Column const& m_column;
+            size_t m_stringIndex = 0;
+            size_t m_pos = 0;
+
+            size_t m_len = 0;
+            size_t m_end = 0;
+            bool m_suffix = false;
+
+            iterator( Column const& column, size_t stringIndex )
+            :   m_column( column ),
+                m_stringIndex( stringIndex )
+            {}
+
+            auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+            auto isBoundary( size_t at ) const -> bool {
+                assert( at > 0 );
+                assert( at <= line().size() );
+
+                return at == line().size() ||
+                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
+                       isBreakableBefore( line()[at] ) ||
+                       isBreakableAfter( line()[at-1] );
+            }
+
+            void calcLength() {
+                assert( m_stringIndex < m_column.m_strings.size() );
+
+                m_suffix = false;
+                auto width = m_column.m_width-indent();
+                m_end = m_pos;
+                while( m_end < line().size() && line()[m_end] != '\n' )
+                    ++m_end;
+
+                if( m_end < m_pos + width ) {
+                    m_len = m_end - m_pos;
+                }
+                else {
+                    size_t len = width;
+                    while (len > 0 && !isBoundary(m_pos + len))
+                        --len;
+                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
+                        --len;
+
+                    if (len > 0) {
+                        m_len = len;
+                    } else {
+                        m_suffix = true;
+                        m_len = width - 1;
+                    }
+                }
+            }
+
+            auto indent() const -> size_t {
+                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+                return initial == std::string::npos ? m_column.m_indent : initial;
+            }
+
+            auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+                return std::string( indent(), ' ' ) + (m_suffix ? plain + "-" : plain);
+            }
+
+        public:
+            explicit iterator( Column const& column ) : m_column( column ) {
+                assert( m_column.m_width > m_column.m_indent );
+                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
+                calcLength();
+                if( m_len == 0 )
+                    m_stringIndex++; // Empty string
+            }
+
+            auto operator *() const -> std::string {
+                assert( m_stringIndex < m_column.m_strings.size() );
+                assert( m_pos <= m_end );
+                if( m_pos + m_column.m_width < m_end )
+                    return addIndentAndSuffix(line().substr(m_pos, m_len));
+                else
+                    return addIndentAndSuffix(line().substr(m_pos, m_end - m_pos));
+            }
+
+            auto operator ++() -> iterator& {
+                m_pos += m_len;
+                if( m_pos < line().size() && line()[m_pos] == '\n' )
+                    m_pos += 1;
+                else
+                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
+                        ++m_pos;
+
+                if( m_pos == line().size() ) {
+                    m_pos = 0;
+                    ++m_stringIndex;
+                }
+                if( m_stringIndex < m_column.m_strings.size() )
+                    calcLength();
+                return *this;
+            }
+            auto operator ++(int) -> iterator {
+                iterator prev( *this );
+                operator++();
+                return prev;
+            }
+
+            auto operator ==( iterator const& other ) const -> bool {
+                return
+                    m_pos == other.m_pos &&
+                    m_stringIndex == other.m_stringIndex &&
+                    &m_column == &other.m_column;
+            }
+            auto operator !=( iterator const& other ) const -> bool {
+                return !operator==( other );
+            }
+        };
+        using const_iterator = iterator;
+
+        explicit Column( std::string const& text ) { m_strings.push_back( text ); }
+
+        auto width( size_t newWidth ) -> Column& {
+            assert( newWidth > 0 );
+            m_width = newWidth;
+            return *this;
+        }
+        auto indent( size_t newIndent ) -> Column& {
+            m_indent = newIndent;
+            return *this;
+        }
+        auto initialIndent( size_t newIndent ) -> Column& {
+            m_initialIndent = newIndent;
+            return *this;
+        }
+
+        auto width() const -> size_t { return m_width; }
+        auto begin() const -> iterator { return iterator( *this ); }
+        auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+        inline friend std::ostream& operator << ( std::ostream& os, Column const& col ) {
+            bool first = true;
+            for( auto line : col ) {
+                if( first )
+                    first = false;
+                else
+                    os << "\n";
+                os <<  line;
+            }
+            return os;
+        }
+
+        auto operator + ( Column const& other ) -> Columns;
+
+        auto toString() const -> std::string {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+    };
+
+    class Spacer : public Column {
+
+    public:
+        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
+            width( spaceWidth );
+        }
+    };
+
+    class Columns {
+        std::vector<Column> m_columns;
+
+    public:
+
+        class iterator {
+            friend Columns;
+            struct EndTag {};
+
+            std::vector<Column> const& m_columns;
+            std::vector<Column::iterator> m_iterators;
+            size_t m_activeIterators;
+
+            iterator( Columns const& columns, EndTag )
+            :   m_columns( columns.m_columns ),
+                m_activeIterators( 0 )
+            {
+                m_iterators.reserve( m_columns.size() );
+
+                for( auto const& col : m_columns )
+                    m_iterators.push_back( col.end() );
+            }
+
+        public:
+            explicit iterator( Columns const& columns )
+            :   m_columns( columns.m_columns ),
+                m_activeIterators( m_columns.size() )
+            {
+                m_iterators.reserve( m_columns.size() );
+
+                for( auto const& col : m_columns )
+                    m_iterators.push_back( col.begin() );
+            }
+
+            auto operator ==( iterator const& other ) const -> bool {
+                return m_iterators == other.m_iterators;
+            }
+            auto operator !=( iterator const& other ) const -> bool {
+                return m_iterators != other.m_iterators;
+            }
+            auto operator *() const -> std::string {
+                std::string row, padding;
+
+                for( size_t i = 0; i < m_columns.size(); ++i ) {
+                    auto width = m_columns[i].width();
+                    if( m_iterators[i] != m_columns[i].end() ) {
+                        std::string col = *m_iterators[i];
+                        row += padding + col;
+                        if( col.size() < width )
+                            padding = std::string( width - col.size(), ' ' );
+                        else
+                            padding = "";
+                    }
+                    else {
+                        padding += std::string( width, ' ' );
+                    }
+                }
+                return row;
+            }
+            auto operator ++() -> iterator& {
+                for( size_t i = 0; i < m_columns.size(); ++i ) {
+                    if (m_iterators[i] != m_columns[i].end())
+                        ++m_iterators[i];
+                }
+                return *this;
+            }
+            auto operator ++(int) -> iterator {
+                iterator prev( *this );
+                operator++();
+                return prev;
+            }
+        };
+        using const_iterator = iterator;
+
+        auto begin() const -> iterator { return iterator( *this ); }
+        auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+        auto operator += ( Column const& col ) -> Columns& {
+            m_columns.push_back( col );
+            return *this;
+        }
+        auto operator + ( Column const& col ) -> Columns {
+            Columns combined = *this;
+            combined += col;
+            return combined;
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& os, Columns const& cols ) {
+
+            bool first = true;
+            for( auto line : cols ) {
+                if( first )
+                    first = false;
+                else
+                    os << "\n";
+                os << line;
+            }
+            return os;
+        }
+
+        auto toString() const -> std::string {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+    };
+
+    inline auto Column::operator + ( Column const& other ) -> Columns {
+        Columns cols;
+        cols += *this;
+        cols += other;
+        return cols;
+    }
+}} // namespace clara::TextFlow
+
+#endif // CLARA_TEXTFLOW_HPP_INCLUDED
+
+// ----------- end of #include from clara_textflow.hpp -----------
+// ........... back in clara.hpp
+
+
+#include <memory>
+#include <set>
+#include <algorithm>
+
+#if !defined(CLARA_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#define CLARA_PLATFORM_WINDOWS
+#endif
+
+namespace clara {
+namespace detail {
+
+    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
+    template<typename L>
+    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+    template<typename ClassT, typename ReturnT, typename... Args>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+        static const bool isValid = false;
+    };
+
+    template<typename ClassT, typename ReturnT, typename ArgT>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+        static const bool isValid = true;
+        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+        using ReturnType = ReturnT;
+    };
+
+    class TokenStream;
+
+    // Transport for raw args (copied from main args, or supplied via init list for testing)
+    class Args {
+        friend TokenStream;
+        std::string m_exeName;
+        std::vector<std::string> m_args;
+
+    public:
+        Args( int argc, char *argv[] ) {
+            m_exeName = argv[0];
+            for( int i = 1; i < argc; ++i )
+                m_args.push_back( argv[i] );
+        }
+
+        Args( std::initializer_list<std::string> args )
+        :   m_exeName( *args.begin() ),
+            m_args( args.begin()+1, args.end() )
+        {}
+
+        auto exeName() const -> std::string {
+            return m_exeName;
+        }
+    };
+
+    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+    // may encode an option + its argument if the : or = form is used
+    enum class TokenType {
+        Option, Argument
+    };
+    struct Token {
+        TokenType type;
+        std::string token;
+    };
+
+    inline auto isOptPrefix( char c ) -> bool {
+        return c == '-'
+#ifdef CLARA_PLATFORM_WINDOWS
+            || c == '/'
+#endif
+        ;
+    }
+
+    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
+    class TokenStream {
+        using Iterator = std::vector<std::string>::const_iterator;
+        Iterator it;
+        Iterator itEnd;
+        std::vector<Token> m_tokenBuffer;
+
+        void loadBuffer() {
+            m_tokenBuffer.resize( 0 );
+
+            // Skip any empty strings
+            while( it != itEnd && it->empty() )
+                ++it;
+
+            if( it != itEnd ) {
+                auto const &next = *it;
+                if( isOptPrefix( next[0] ) ) {
+                    auto delimiterPos = next.find_first_of( " :=" );
+                    if( delimiterPos != std::string::npos ) {
+                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
+                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
+                    } else {
+                        if( next[1] != '-' && next.size() > 2 ) {
+                            std::string opt = "- ";
+                            for( size_t i = 1; i < next.size(); ++i ) {
+                                opt[1] = next[i];
+                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
+                            }
+                        } else {
+                            m_tokenBuffer.push_back( { TokenType::Option, next } );
+                        }
+                    }
+                } else {
+                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
+                }
+            }
+        }
+
+    public:
+        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+            loadBuffer();
+        }
+
+        explicit operator bool() const {
+            return !m_tokenBuffer.empty() || it != itEnd;
+        }
+
+        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
+
+        auto operator*() const -> Token {
+            assert( !m_tokenBuffer.empty() );
+            return m_tokenBuffer.front();
+        }
+
+        auto operator->() const -> Token const * {
+            assert( !m_tokenBuffer.empty() );
+            return &m_tokenBuffer.front();
+        }
+
+        auto operator++() -> TokenStream & {
+            if( m_tokenBuffer.size() >= 2 ) {
+                m_tokenBuffer.erase( m_tokenBuffer.begin() );
+            } else {
+                if( it != itEnd )
+                    ++it;
+                loadBuffer();
+            }
+            return *this;
+        }
+    };
+
+
+    class ResultBase {
+    public:
+        enum Type {
+            Ok, LogicError, RuntimeError
+        };
+
+    protected:
+        ResultBase( Type type ) : m_type( type ) {}
+        virtual ~ResultBase() = default;
+
+        virtual void enforceOk() const = 0;
+
+        Type m_type;
+    };
+
+    template<typename T>
+    class ResultValueBase : public ResultBase {
+    public:
+        auto value() const -> T const & {
+            enforceOk();
+            return m_value;
+        }
+
+    protected:
+        ResultValueBase( Type type ) : ResultBase( type ) {}
+
+        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+        }
+
+        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+            new( &m_value ) T( value );
+        }
+
+        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
+            if( m_type == ResultBase::Ok )
+                m_value.~T();
+            ResultBase::operator=(other);
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+            return *this;
+        }
+
+        ~ResultValueBase() override {
+            if( m_type == Ok )
+                m_value.~T();
+        }
+
+        union {
+            T m_value;
+        };
+    };
+
+    template<>
+    class ResultValueBase<void> : public ResultBase {
+    protected:
+        using ResultBase::ResultBase;
+    };
+
+    template<typename T = void>
+    class BasicResult : public ResultValueBase<T> {
+    public:
+        template<typename U>
+        explicit BasicResult( BasicResult<U> const &other )
+        :   ResultValueBase<T>( other.type() ),
+            m_errorMessage( other.errorMessage() )
+        {
+            assert( type() != ResultBase::Ok );
+        }
+
+        template<typename U>
+        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+
+        explicit operator bool() const { return m_type == ResultBase::Ok; }
+        auto type() const -> ResultBase::Type { return m_type; }
+        auto errorMessage() const -> std::string { return m_errorMessage; }
+
+    protected:
+        void enforceOk() const override {
+            // !TBD: If no exceptions, std::terminate here or something
+            switch( m_type ) {
+                case ResultBase::LogicError:
+                    throw std::logic_error( m_errorMessage );
+                case ResultBase::RuntimeError:
+                    throw std::runtime_error( m_errorMessage );
+                case ResultBase::Ok:
+                    break;
+            }
+        }
+
+        std::string m_errorMessage; // Only populated if resultType is an error
+
+        BasicResult( ResultBase::Type type, std::string const &message )
+        :   ResultValueBase<T>(type),
+            m_errorMessage(message)
+        {
+            assert( m_type != ResultBase::Ok );
+        }
+
+        using ResultValueBase<T>::ResultValueBase;
+        using ResultBase::m_type;
+    };
+
+    enum class ParseResultType {
+        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
+    };
+
+    class ParseState {
+    public:
+
+        ParseState( ParseResultType type, TokenStream const &remainingTokens )
+        : m_type(type),
+          m_remainingTokens( remainingTokens )
+        {}
+
+        auto type() const -> ParseResultType { return m_type; }
+        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
+
+    private:
+        ParseResultType m_type;
+        TokenStream m_remainingTokens;
+    };
+
+    using Result = BasicResult<void>;
+    using ParserResult = BasicResult<ParseResultType>;
+    using InternalParseResult = BasicResult<ParseState>;
+
+    struct HelpColumns {
+        std::string left;
+        std::string right;
+    };
+
+    template<typename T>
+    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+        std::stringstream ss;
+        ss << source;
+        ss >> target;
+        if( ss.fail() )
+            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+        else
+            return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+        target = source;
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+        std::string srcLC = source;
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
+        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
+            target = true;
+        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
+            target = false;
+        else
+            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+
+    struct NonCopyable {
+        NonCopyable() = default;
+        NonCopyable( NonCopyable const & ) = delete;
+        NonCopyable( NonCopyable && ) = delete;
+        NonCopyable &operator=( NonCopyable const & ) = delete;
+        NonCopyable &operator=( NonCopyable && ) = delete;
+    };
+
+    struct BoundRef : NonCopyable {
+        virtual ~BoundRef() = default;
+        virtual auto isContainer() const -> bool { return false; }
+        virtual auto isFlag() const -> bool { return false; }
+    };
+    struct BoundValueRefBase : BoundRef {
+        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
+    };
+    struct BoundFlagRefBase : BoundRef {
+        virtual auto setFlag( bool flag ) -> ParserResult = 0;
+        virtual auto isFlag() const -> bool { return true; }
+    };
+
+    template<typename T>
+    struct BoundValueRef : BoundValueRefBase {
+        T &m_ref;
+
+        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return convertInto( arg, m_ref );
+        }
+    };
+
+    template<typename T>
+    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+        std::vector<T> &m_ref;
+
+        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+
+        auto isContainer() const -> bool override { return true; }
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            T temp;
+            auto result = convertInto( arg, temp );
+            if( result )
+                m_ref.push_back( temp );
+            return result;
+        }
+    };
+
+    struct BoundFlagRef : BoundFlagRefBase {
+        bool &m_ref;
+
+        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            m_ref = flag;
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ReturnType>
+    struct LambdaInvoker {
+        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            return lambda( arg );
+        }
+    };
+
+    template<>
+    struct LambdaInvoker<void> {
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            lambda( arg );
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ArgType, typename L>
+    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+        ArgType temp{};
+        auto result = convertInto( arg, temp );
+        return !result
+           ? result
+           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
+    }
+
+
+    template<typename L>
+    struct BoundLambda : BoundValueRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+        }
+    };
+
+    template<typename L>
+    struct BoundFlagLambda : BoundFlagRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+
+        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+        }
+    };
+
+    enum class Optionality { Optional, Required };
+
+    struct Parser;
+
+    class ParserBase {
+    public:
+        virtual ~ParserBase() = default;
+        virtual auto validate() const -> Result { return Result::ok(); }
+        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+        virtual auto cardinality() const -> size_t { return 1; }
+
+        auto parse( Args const &args ) const -> InternalParseResult {
+            return parse( args.exeName(), TokenStream( args ) );
+        }
+    };
+
+    template<typename DerivedT>
+    class ComposableParserImpl : public ParserBase {
+    public:
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser;
+
+		template<typename T>
+        auto operator+( T const &other ) const -> Parser;
+    };
+
+    // Common code and state for Args and Opts
+    template<typename DerivedT>
+    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+    protected:
+        Optionality m_optionality = Optionality::Optional;
+        std::shared_ptr<BoundRef> m_ref;
+        std::string m_hint;
+        std::string m_description;
+
+        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+
+    public:
+        template<typename T>
+        ParserRefImpl( T &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+            m_hint( hint )
+        {}
+
+        template<typename LambdaT>
+        ParserRefImpl( LambdaT const &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+            m_hint(hint)
+        {}
+
+        auto operator()( std::string const &description ) -> DerivedT & {
+            m_description = description;
+            return static_cast<DerivedT &>( *this );
+        }
+
+        auto optional() -> DerivedT & {
+            m_optionality = Optionality::Optional;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto required() -> DerivedT & {
+            m_optionality = Optionality::Required;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto isOptional() const -> bool {
+            return m_optionality == Optionality::Optional;
+        }
+
+        auto cardinality() const -> size_t override {
+            if( m_ref->isContainer() )
+                return 0;
+            else
+                return 1;
+        }
+
+        auto hint() const -> std::string { return m_hint; }
+    };
+
+    class ExeName : public ComposableParserImpl<ExeName> {
+        std::shared_ptr<std::string> m_name;
+        std::shared_ptr<BoundValueRefBase> m_ref;
+
+        template<typename LambdaT>
+        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+        }
+
+    public:
+        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+
+        explicit ExeName( std::string &ref ) : ExeName() {
+            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+        }
+
+        template<typename LambdaT>
+        explicit ExeName( LambdaT const& lambda ) : ExeName() {
+            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+        }
+
+        // The exe name is not parsed out of the normal tokens, but is handled specially
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+        }
+
+        auto name() const -> std::string { return *m_name; }
+        auto set( std::string const& newName ) -> ParserResult {
+
+            auto lastSlash = newName.find_last_of( "\\/" );
+            auto filename = ( lastSlash == std::string::npos )
+                    ? newName
+                    : newName.substr( lastSlash+1 );
+
+            *m_name = filename;
+            if( m_ref )
+                return m_ref->setValue( filename );
+            else
+                return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    class Arg : public ParserRefImpl<Arg> {
+    public:
+        using ParserRefImpl::ParserRefImpl;
+
+        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            auto const &token = *remainingTokens;
+            if( token.type != TokenType::Argument )
+                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+
+            assert( !m_ref->isFlag() );
+            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+
+            auto result = valueRef->setValue( remainingTokens->token );
+            if( !result )
+                return InternalParseResult( result );
+            else
+                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+        }
+    };
+
+    inline auto normaliseOpt( std::string const &optName ) -> std::string {
+#ifdef CLARA_PLATFORM_WINDOWS
+        if( optName[0] == '/' )
+            return "-" + optName.substr( 1 );
+        else
+#endif
+            return optName;
+    }
+
+    class Opt : public ParserRefImpl<Opt> {
+    protected:
+        std::vector<std::string> m_optNames;
+
+    public:
+        template<typename LambdaT>
+        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+
+        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+
+        template<typename LambdaT>
+        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        template<typename T>
+        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        auto operator[]( std::string const &optName ) -> Opt & {
+            m_optNames.push_back( optName );
+            return *this;
+        }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::ostringstream oss;
+            bool first = true;
+            for( auto const &opt : m_optNames ) {
+                if (first)
+                    first = false;
+                else
+                    oss << ", ";
+                oss << opt;
+            }
+            if( !m_hint.empty() )
+                oss << " <" << m_hint << ">";
+            return { { oss.str(), m_description } };
+        }
+
+        auto isMatch( std::string const &optToken ) const -> bool {
+            auto normalisedToken = normaliseOpt( optToken );
+            for( auto const &name : m_optNames ) {
+                if( normaliseOpt( name ) == normalisedToken )
+                    return true;
+            }
+            return false;
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
+                auto const &token = *remainingTokens;
+                if( isMatch(token.token ) ) {
+                    if( m_ref->isFlag() ) {
+                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
+                        auto result = flagRef->setFlag( true );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    } else {
+                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+                        ++remainingTokens;
+                        if( !remainingTokens )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto const &argToken = *remainingTokens;
+                        if( argToken.type != TokenType::Argument )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto result = valueRef->setValue( argToken.token );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    }
+                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+                }
+            }
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+        }
+
+        auto validate() const -> Result override {
+            if( m_optNames.empty() )
+                return Result::logicError( "No options supplied to Opt" );
+            for( auto const &name : m_optNames ) {
+                if( name.empty() )
+                    return Result::logicError( "Option name cannot be empty" );
+#ifdef CLARA_PLATFORM_WINDOWS
+                if( name[0] != '-' && name[0] != '/' )
+                    return Result::logicError( "Option name must begin with '-' or '/'" );
+#else
+                if( name[0] != '-' )
+                    return Result::logicError( "Option name must begin with '-'" );
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+    };
+
+    struct Help : Opt {
+        Help( bool &showHelpFlag )
+        :   Opt([&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            })
+        {
+            static_cast<Opt &>( *this )
+                    ("display usage information")
+                    ["-?"]["-h"]["--help"]
+                    .optional();
+        }
+    };
+
+
+    struct Parser : ParserBase {
+
+        mutable ExeName m_exeName;
+        std::vector<Opt> m_options;
+        std::vector<Arg> m_args;
+
+        auto operator|=( ExeName const &exeName ) -> Parser & {
+            m_exeName = exeName;
+            return *this;
+        }
+
+        auto operator|=( Arg const &arg ) -> Parser & {
+            m_args.push_back(arg);
+            return *this;
+        }
+
+        auto operator|=( Opt const &opt ) -> Parser & {
+            m_options.push_back(opt);
+            return *this;
+        }
+
+        auto operator|=( Parser const &other ) -> Parser & {
+            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+            return *this;
+        }
+
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser {
+            return Parser( *this ) |= other;
+        }
+
+        // Forward deprecated interface with '+' instead of '|'
+        template<typename T>
+        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+        template<typename T>
+        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::vector<HelpColumns> cols;
+            for (auto const &o : m_options) {
+                auto childCols = o.getHelpColumns();
+                cols.insert( cols.end(), childCols.begin(), childCols.end() );
+            }
+            return cols;
+        }
+
+        void writeToStream( std::ostream &os ) const {
+            if (!m_exeName.name().empty()) {
+                os << "usage:\n" << "  " << m_exeName.name() << " ";
+                bool required = true, first = true;
+                for( auto const &arg : m_args ) {
+                    if (first)
+                        first = false;
+                    else
+                        os << " ";
+                    if( arg.isOptional() && required ) {
+                        os << "[";
+                        required = false;
+                    }
+                    os << "<" << arg.hint() << ">";
+                    if( arg.cardinality() == 0 )
+                        os << " ... ";
+                }
+                if( !required )
+                    os << "]";
+                if( !m_options.empty() )
+                    os << " options";
+                os << "\n\nwhere options are:" << std::endl;
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
+            size_t optWidth = 0;
+            for( auto const &cols : rows )
+                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+
+            optWidth = (std::min)(optWidth, consoleWidth/2);
+
+            for( auto const &cols : rows ) {
+                auto row =
+                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
+                        TextFlow::Spacer(4) +
+                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
+                os << row << std::endl;
+            }
+        }
+
+        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
+            parser.writeToStream( os );
+            return os;
+        }
+
+        auto validate() const -> Result override {
+            for( auto const &opt : m_options ) {
+                auto result = opt.validate();
+                if( !result )
+                    return result;
+            }
+            for( auto const &arg : m_args ) {
+                auto result = arg.validate();
+                if( !result )
+                    return result;
+            }
+            return Result::ok();
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            const size_t totalParsers = m_options.size() + m_args.size();
+            assert( totalParsers < 512 );
+            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+            ParserInfo parseInfos[512];
+
+            {
+                size_t i = 0;
+                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
+                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+            while( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for( size_t i = 0; i < totalParsers; ++i ) {
+                    auto&  parseInfo = parseInfos[i];
+                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+                        if (!result)
+                            return result;
+                        if (result.value().type() != ParseResultType::NoMatch) {
+                            tokenParsed = true;
+                            ++parseInfo.count;
+                            break;
+                        }
+                    }
+                }
+
+                if( result.value().type() == ParseResultType::ShortCircuitAll )
+                    return result;
+                if( !tokenParsed )
+                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+    };
+
+    template<typename DerivedT>
+    template<typename T>
+    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
+        return Parser() | static_cast<DerivedT const &>( *this ) | other;
+    }
+} // namespace detail
+
+
+// A Combined parser
+using detail::Parser;
+
+// A parser for options
+using detail::Opt;
+
+// A parser for arguments
+using detail::Arg;
+
+// Wrapper for argc, argv from main()
+using detail::Args;
+
+// Specifies the name of the executable
+using detail::ExeName;
+
+// Convenience wrapper for option parser that specifies the help option
+using detail::Help;
+
+// enum of result types from a parse
+using detail::ParseResultType;
+
+// Result type for parser operation
+using detail::ParserResult;
+
+
+} // namespace clara
+
+#endif // CLARA_HPP_INCLUDED
diff --git a/third_party/vtzero/include/vtzero/builder.hpp b/third_party/vtzero/include/vtzero/builder.hpp
new file mode 100644
index 00000000000..666d3cb3322
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/builder.hpp
@@ -0,0 +1,1256 @@
+#ifndef VTZERO_BUILDER_HPP
+#define VTZERO_BUILDER_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file builder.hpp
+ *
+ * @brief Contains the classes and functions to build vector tiles.
+ */
+
+#include "builder_impl.hpp"
+#include "feature_builder_impl.hpp"
+#include "geometry.hpp"
+#include "types.hpp"
+#include "vector_tile.hpp"
+
+#include <protozero/pbf_builder.hpp>
+
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace vtzero {
+
+    /**
+     * Used to build vector tiles. Whenever you are building a new vector
+     * tile, start with an object of this class and add layers. After all
+     * the data is added, call serialize().
+     *
+     * @code
+     * layer some_existing_layer = ...;
+     *
+     * tile_builder builder;
+     * layer_builder layer_roads{builder, "roads"};
+     * builder.add_existing_layer(some_existing_layer);
+     * ...
+     * std::string data = builder.serialize();
+     * @endcode
+     */
+    class tile_builder {
+
+        friend class layer_builder;
+
+        std::vector<std::unique_ptr<detail::layer_builder_base>> m_layers;
+
+        /**
+         * Add a new layer to the vector tile based on an existing layer. The
+         * new layer will have the same name, version, and extent as the
+         * existing layer. The new layer will not contain any features. This
+         * method is handy when copying some (but not all) data from an
+         * existing layer.
+         */
+        detail::layer_builder_impl* add_layer(const layer& layer) {
+            const auto ptr = new detail::layer_builder_impl{layer.name(), layer.version(), layer.extent()};
+            m_layers.emplace_back(ptr);
+            return ptr;
+        }
+
+        /**
+         * Add a new layer to the vector tile with the specified name, version,
+         * and extent.
+         *
+         * @tparam TString Some string type (const char*, std::string,
+         *         vtzero::data_view) or something that converts to one of
+         *         these types.
+         * @param name Name of this layer.
+         * @param version Version of this layer (only version 1 and 2 are
+         *                supported)
+         * @param extent Extent used for this layer.
+         */
+        template <typename TString>
+        detail::layer_builder_impl* add_layer(TString&& name, uint32_t version, uint32_t extent) {
+            const auto ptr = new detail::layer_builder_impl{std::forward<TString>(name), version, extent};
+            m_layers.emplace_back(ptr);
+            return ptr;
+        }
+
+    public:
+
+        /// Constructor
+        tile_builder() = default;
+
+        /// Destructor
+        ~tile_builder() noexcept = default;
+
+        /// Tile builders can not be copied.
+        tile_builder(const tile_builder&) = delete;
+
+        /// Tile builders can not be copied.
+        tile_builder& operator=(const tile_builder&) = delete;
+
+        /// Tile builders can be moved.
+        tile_builder(tile_builder&&) = default;
+
+        /// Tile builders can be moved.
+        tile_builder& operator=(tile_builder&&) = default;
+
+        /**
+         * Add an existing layer to the vector tile. The layer data will be
+         * copied over into the new vector_tile when the serialize() method
+         * is called. Until then, the data referenced here must stay available.
+         *
+         * @param data Reference to some data that must be a valid encoded
+         *        layer.
+         */
+        void add_existing_layer(data_view&& data) {
+            m_layers.emplace_back(new detail::layer_builder_existing{std::forward<data_view>(data)});
+        }
+
+        /**
+         * Add an existing layer to the vector tile. The layer data will be
+         * copied over into the new vector_tile when the serialize() method
+         * is called. Until then, the data referenced here must stay available.
+         *
+         * @param layer Reference to the layer to be copied.
+         */
+        void add_existing_layer(const layer& layer) {
+            add_existing_layer(layer.data());
+        }
+
+        /**
+         * Serialize the data accumulated in this builder into a vector tile.
+         * The data will be appended to the specified buffer. The buffer
+         * doesn't have to be empty.
+         *
+         * @param buffer Buffer to append the encoded vector tile to.
+         */
+        void serialize(std::string& buffer) const {
+            std::size_t estimated_size = 0;
+            for (const auto& layer : m_layers) {
+                estimated_size += layer->estimated_size();
+            }
+
+            buffer.reserve(buffer.size() + estimated_size);
+
+            protozero::pbf_builder<detail::pbf_tile> pbf_tile_builder{buffer};
+            for (const auto& layer : m_layers) {
+                layer->build(pbf_tile_builder);
+            }
+        }
+
+        /**
+         * Serialize the data accumulated in this builder into a vector_tile
+         * and return it.
+         *
+         * If you want to use an existing buffer instead, use the serialize()
+         * method taking a std::string& as parameter.
+         *
+         * @returns std::string Buffer with encoded vector_tile data.
+         */
+        std::string serialize() const {
+            std::string data;
+            serialize(data);
+            return data;
+        }
+
+    }; // class tile_builder
+
+    /**
+     * The layer_builder is used to add a new layer to a vector tile that is
+     * being built.
+     */
+    class layer_builder {
+
+        vtzero::detail::layer_builder_impl* m_layer;
+
+        friend class geometry_feature_builder;
+        friend class point_feature_builder;
+        friend class linestring_feature_builder;
+        friend class polygon_feature_builder;
+
+        vtzero::detail::layer_builder_impl& get_layer_impl() noexcept {
+            return *m_layer;
+        }
+
+        template <typename T>
+        using is_layer = std::is_same<typename std::remove_cv<typename std::remove_reference<T>::type>::type, layer>;
+
+    public:
+
+        /**
+         * Construct a layer_builder to build a new layer with the same name,
+         * version, and extent as an existing layer.
+         *
+         * @param tile The tile builder we want to create this layer in.
+         * @param layer Existing layer we want to use the name, version, and
+         *        extent from
+         */
+        layer_builder(vtzero::tile_builder& tile, const layer& layer) :
+            m_layer(tile.add_layer(layer)) {
+        }
+
+        /**
+         * Construct a layer_builder to build a completely new layer.
+         *
+         * @tparam TString Some string type (such as std::string or const char*)
+         * @param tile The tile builder we want to create this layer in.
+         * @param name The name of the new layer.
+         * @param version The vector tile spec version of the new layer.
+         * @param extent The extent of the new layer.
+         */
+        template <typename TString, typename std::enable_if<!is_layer<TString>::value, int>::type = 0>
+        layer_builder(vtzero::tile_builder& tile, TString&& name, uint32_t version = 2, uint32_t extent = 4096) :
+            m_layer(tile.add_layer(std::forward<TString>(name), version, extent)) {
+        }
+
+        /**
+         * Add key to the keys table without checking for duplicates. This
+         * function is usually used when an external index is used which takes
+         * care of the duplication check.
+         *
+         * @param text The key.
+         * @returns The index value of this key.
+         */
+        index_value add_key_without_dup_check(const data_view text) {
+            return m_layer->add_key_without_dup_check(text);
+        }
+
+        /**
+         * Add key to the keys table. This function will consult the internal
+         * index in the layer to make sure the key is only in the table once.
+         * It will either return the index value of an existing key or add the
+         * new key and return its index value.
+         *
+         * @param text The key.
+         * @returns The index value of this key.
+         */
+        index_value add_key(const data_view text) {
+            return m_layer->add_key(text);
+        }
+
+        /**
+         * Add value to the values table without checking for duplicates. This
+         * function is usually used when an external index is used which takes
+         * care of the duplication check.
+         *
+         * @param value The property value.
+         * @returns The index value of this value.
+         */
+        index_value add_value_without_dup_check(const property_value value) {
+            return m_layer->add_value_without_dup_check(value);
+        }
+
+        /**
+         * Add value to the values table without checking for duplicates. This
+         * function is usually used when an external index is used which takes
+         * care of the duplication check.
+         *
+         * @param value The property value.
+         * @returns The index value of this value.
+         */
+        index_value add_value_without_dup_check(const encoded_property_value& value) {
+            return m_layer->add_value_without_dup_check(value);
+        }
+
+        /**
+         * Add value to the values table. This function will consult the
+         * internal index in the layer to make sure the value is only in the
+         * table once. It will either return the index value of an existing
+         * value or add the new value and return its index value.
+         *
+         * @param value The property value.
+         * @returns The index value of this value.
+         */
+        index_value add_value(const property_value value) {
+            return m_layer->add_value(value);
+        }
+
+        /**
+         * Add value to the values table. This function will consult the
+         * internal index in the layer to make sure the value is only in the
+         * table once. It will either return the index value of an existing
+         * value or add the new value and return its index value.
+         *
+         * @param value The property value.
+         * @returns The index value of this value.
+         */
+        index_value add_value(const encoded_property_value& value) {
+            return m_layer->add_value(value);
+        }
+
+        /**
+         * Add a feature from an existing layer to the new layer. The feature
+         * will be copied completely over to the new layer including its
+         * geometry and all its properties.
+         */
+        void add_feature(const feature& feature);
+
+    }; // class layer_builder
+
+    /**
+     * Parent class for the point_feature_builder, linestring_feature_builder
+     * and polygon_feature_builder classes. You can not instantiate this class
+     * directly, use it through its derived classes.
+     */
+    class feature_builder : public detail::feature_builder_base {
+
+        class countdown_value {
+
+            uint32_t m_value = 0;
+
+        public:
+
+            countdown_value() noexcept = default;
+
+            ~countdown_value() noexcept {
+                assert_is_zero();
+            }
+
+            countdown_value(const countdown_value&) = delete;
+
+            countdown_value& operator=(const countdown_value&) = delete;
+
+            countdown_value(countdown_value&& other) noexcept :
+                m_value(other.m_value) {
+                other.m_value = 0;
+            }
+
+            countdown_value& operator=(countdown_value&& other) noexcept {
+                m_value = other.m_value;
+                other.m_value = 0;
+                return *this;
+            }
+
+            uint32_t value() const noexcept {
+                return m_value;
+            }
+
+            void set(const uint32_t value) noexcept {
+                m_value = value;
+            }
+
+            void decrement() {
+                vtzero_assert(m_value > 0 && "too many calls to set_point()");
+                --m_value;
+            }
+
+            void assert_is_zero() const noexcept {
+                vtzero_assert_in_noexcept_function(m_value == 0 &&
+                                                   "not enough calls to set_point()");
+            }
+
+        }; // countdown_value
+
+    protected:
+
+        /// Encoded geometry.
+        protozero::packed_field_uint32 m_pbf_geometry{};
+
+        /// Number of points still to be set for the geometry to be complete.
+        countdown_value m_num_points;
+
+        /// Last point (used to calculate delta between coordinates)
+        point m_cursor{0, 0};
+
+        /// Constructor.
+        explicit feature_builder(detail::layer_builder_impl* layer) :
+            feature_builder_base(layer) {
+        }
+
+        /// Helper function to check size isn't too large
+        template <typename T>
+        uint32_t check_num_points(T size) {
+            if (size >= (1ul << 29u)) {
+                throw geometry_exception{"Maximum of 2^29 - 1 points allowed in geometry"};
+            }
+            return static_cast<uint32_t>(size);
+        }
+
+        /// Helper function to make sure we have everything before adding a property
+        void prepare_to_add_property() {
+            if (m_pbf_geometry.valid()) {
+                m_num_points.assert_is_zero();
+                m_pbf_geometry.commit();
+            }
+            if (!m_pbf_tags.valid()) {
+                m_pbf_tags = {m_feature_writer, detail::pbf_feature::tags};
+            }
+        }
+
+    public:
+
+        /**
+         * If the feature was not committed, the destructor will roll back all
+         * the changes.
+         */
+        ~feature_builder() {
+            try {
+                rollback();
+            } catch (...) {
+                // ignore exceptions
+            }
+        }
+
+        /// Builder classes can not be copied
+        feature_builder(const feature_builder&) = delete;
+
+        /// Builder classes can not be copied
+        feature_builder& operator=(const feature_builder&) = delete;
+
+        /// Builder classes can be moved
+        feature_builder(feature_builder&& other) noexcept = default;
+
+        /// Builder classes can be moved
+        feature_builder& operator=(feature_builder&& other) noexcept = default;
+
+        /**
+         * Set the ID of this feature.
+         *
+         * You can only call this method once and it must be before calling
+         * any other method manipulating the geometry.
+         *
+         * @param id The ID.
+         */
+        void set_id(uint64_t id) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not call set_id() after commit() or rollback()");
+            vtzero_assert(!m_pbf_geometry.valid() &&
+                          !m_pbf_tags.valid() &&
+                          "Call set_id() before setting the geometry or adding properties");
+            m_feature_writer.add_uint64(detail::pbf_feature::id, id);
+        }
+
+        /**
+         * Add a property to this feature. Can only be called after all the
+         * methods manipulating the geometry.
+         *
+         * @tparam TProp Can be type index_value_pair or property.
+         * @param prop The property to add.
+         */
+        template <typename TProp>
+        void add_property(TProp&& prop) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not call add_property() after commit() or rollback()");
+            prepare_to_add_property();
+            add_property_impl(std::forward<TProp>(prop));
+        }
+
+        /**
+         * Add a property to this feature. Can only be called after all the
+         * methods manipulating the geometry.
+         *
+         * @tparam TKey Can be type index_value or data_view or anything that
+         *         converts to it.
+         * @tparam TValue Can be type index_value or property_value or
+         *         encoded_property or anything that converts to it.
+         * @param key The key.
+         * @param value The value.
+         */
+        template <typename TKey, typename TValue>
+        void add_property(TKey&& key, TValue&& value) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not call add_property() after commit() or rollback()");
+            prepare_to_add_property();
+            add_property_impl(std::forward<TKey>(key), std::forward<TValue>(value));
+        }
+
+        /**
+         * Commit this feature. Call this after all the details of this
+         * feature have been added. If this is not called, the feature
+         * will be rolled back when the destructor of the feature_builder is
+         * called.
+         *
+         * Once a feature has been committed or rolled back, further calls
+         * to commit() or rollback() don't do anything.
+         */
+        void commit() {
+            if (m_feature_writer.valid()) {
+                vtzero_assert((m_pbf_geometry.valid() || m_pbf_tags.valid()) &&
+                              "Can not call commit before geometry was added");
+                if (m_pbf_geometry.valid()) {
+                    m_pbf_geometry.commit();
+                }
+                do_commit();
+            }
+        }
+
+        /**
+         * Rollback this feature. Removed all traces of this feature from
+         * the layer_builder. Useful when you started creating a feature
+         * but then find out that its geometry is invalid or something like
+         * it. This will also happen automatically when the feature_builder
+         * is destructed and commit() hasn't been called on it.
+         *
+         * Once a feature has been committed or rolled back, further calls
+         * to commit() or rollback() don't do anything.
+         */
+        void rollback() {
+            if (m_feature_writer.valid()) {
+                if (m_pbf_geometry.valid()) {
+                    m_pbf_geometry.rollback();
+                }
+                do_rollback();
+            }
+        }
+
+    }; // class feature_builder
+
+    /**
+     * Used for adding a feature with a point geometry to a layer. After
+     * creating an object of this class you can add data to the feature in a
+     * specific order:
+     *
+     * * Optionally add the ID using set_id().
+     * * Add the (multi)point geometry using add_point(), add_points() and
+     *   set_point(), or add_points_from_container().
+     * * Optionally add any number of properties using add_property().
+     *
+     * @code
+     * vtzero::tile_builder tb;
+     * vtzero::layer_builder lb{tb};
+     * vtzero::point_feature_builder fb{lb};
+     * fb.set_id(123); // optionally set ID
+     * fb.add_point(10, 20) // add point geometry
+     * fb.add_property("foo", "bar"); // add property
+     * @endcode
+     */
+    class point_feature_builder : public feature_builder {
+
+    public:
+
+        /**
+         * Constructor
+         *
+         * @param layer The layer we want to create this feature in.
+         */
+        explicit point_feature_builder(layer_builder layer) :
+            feature_builder(&layer.get_layer_impl()) {
+            m_feature_writer.add_enum(detail::pbf_feature::type, static_cast<int32_t>(GeomType::POINT));
+        }
+
+        /**
+         * Add a single point as the geometry to this feature.
+         *
+         * @param p The point to add.
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void add_point(const point p) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(!m_pbf_geometry.valid() &&
+                          !m_pbf_tags.valid() &&
+                          "add_point() can only be called once");
+            m_pbf_geometry = {m_feature_writer, detail::pbf_feature::geometry};
+            m_pbf_geometry.add_element(detail::command_move_to(1));
+            m_pbf_geometry.add_element(protozero::encode_zigzag32(p.x));
+            m_pbf_geometry.add_element(protozero::encode_zigzag32(p.y));
+        }
+
+        /**
+         * Add a single point as the geometry to this feature.
+         *
+         * @param x X coordinate of the point to add.
+         * @param y Y coordinate of the point to add.
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void add_point(const int32_t x, const int32_t y) {
+            add_point(point{x, y});
+        }
+
+        /**
+         * Add a single point as the geometry to this feature.
+         *
+         * @tparam TPoint A type that can be converted to vtzero::point using
+         *         the create_vtzero_point function.
+         * @param p The point to add.
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        template <typename TPoint>
+        void add_point(TPoint&& p) {
+            add_point(create_vtzero_point(std::forward<TPoint>(p)));
+        }
+
+        /**
+         * Declare the intent to add a multipoint geometry with *count* points
+         * to this feature.
+         *
+         * @param count The number of points in the multipoint geometry.
+         *
+         * @pre @code count > 0 && count < 2^29 @endcode
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void add_points(uint32_t count) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(!m_pbf_geometry.valid() &&
+                          "can not call add_points() twice or mix with add_point()");
+            vtzero_assert(!m_pbf_tags.valid() &&
+                          "add_points() has to be called before properties are added");
+            vtzero_assert(count > 0 && count < (1ul << 29u) && "add_points() must be called with 0 < count < 2^29");
+            m_num_points.set(count);
+            m_pbf_geometry = {m_feature_writer, detail::pbf_feature::geometry};
+            m_pbf_geometry.add_element(detail::command_move_to(count));
+        }
+
+        /**
+         * Set a point in the multipoint geometry.
+         *
+         * @param p The point.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_points(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void set_point(const point p) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(m_pbf_geometry.valid() &&
+                          "call add_points() before set_point()");
+            vtzero_assert(!m_pbf_tags.valid() &&
+                          "set_point() has to be called before properties are added");
+            m_num_points.decrement();
+            m_pbf_geometry.add_element(protozero::encode_zigzag32(p.x - m_cursor.x));
+            m_pbf_geometry.add_element(protozero::encode_zigzag32(p.y - m_cursor.y));
+            m_cursor = p;
+        }
+
+        /**
+         * Set a point in the multipoint geometry.
+         *
+         * @param x X coordinate of the point to set.
+         * @param y Y coordinate of the point to set.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_points(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void set_point(const int32_t x, const int32_t y) {
+            set_point(point{x, y});
+        }
+
+        /**
+         * Set a point in the multipoint geometry.
+         *
+         * @tparam TPoint A type that can be converted to vtzero::point using
+         *         the create_vtzero_point function.
+         * @param p The point to add.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_points(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        template <typename TPoint>
+        void set_point(TPoint&& p) {
+            set_point(create_vtzero_point(std::forward<TPoint>(p)));
+        }
+
+        /**
+         * Add the points from the specified container as multipoint geometry
+         * to this feature.
+         *
+         * @tparam TContainer The container type. Must support the size()
+         *         method, be iterable using a range for loop, and contain
+         *         objects of type vtzero::point or something convertible to
+         *         it.
+         * @param container The container to read the points from.
+         *
+         * @throws geometry_exception If there are more than 2^32-1 members in
+         *         the container.
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        template <typename TContainer>
+        void add_points_from_container(const TContainer& container) {
+            add_points(check_num_points(container.size()));
+            for (const auto& element : container) {
+                set_point(element);
+            }
+        }
+
+    }; // class point_feature_builder
+
+    /**
+     * Used for adding a feature with a (multi)linestring geometry to a layer.
+     * After creating an object of this class you can add data to the
+     * feature in a specific order:
+     *
+     * * Optionally add the ID using set_id().
+     * * Add the (multi)linestring geometry using add_linestring() or
+     *   add_linestring_from_container().
+     * * Optionally add any number of properties using add_property().
+     *
+     * @code
+     * vtzero::tile_builder tb;
+     * vtzero::layer_builder lb{tb};
+     * vtzero::linestring_feature_builder fb{lb};
+     * fb.set_id(123); // optionally set ID
+     * fb.add_linestring(2);
+     * fb.set_point(10, 10);
+     * fb.set_point(10, 20);
+     * fb.add_property("foo", "bar"); // add property
+     * @endcode
+     */
+    class linestring_feature_builder : public feature_builder {
+
+        bool m_start_line = false;
+
+    public:
+
+        /**
+         * Constructor
+         *
+         * @param layer The layer we want to create this feature in.
+         */
+        explicit linestring_feature_builder(layer_builder layer) :
+            feature_builder(&layer.get_layer_impl()) {
+            m_feature_writer.add_enum(detail::pbf_feature::type, static_cast<int32_t>(GeomType::LINESTRING));
+        }
+
+        /**
+         * Declare the intent to add a linestring geometry with *count* points
+         * to this feature.
+         *
+         * @param count The number of points in the linestring.
+         *
+         * @pre @code count > 1 && count < 2^29 @endcode
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void add_linestring(const uint32_t count) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(!m_pbf_tags.valid() &&
+                          "add_linestring() has to be called before properties are added");
+            vtzero_assert(count > 1 && count < (1ul << 29u) && "add_linestring() must be called with 1 < count < 2^29");
+            m_num_points.assert_is_zero();
+            if (!m_pbf_geometry.valid()) {
+                m_pbf_geometry = {m_feature_writer, detail::pbf_feature::geometry};
+            }
+            m_num_points.set(count);
+            m_start_line = true;
+        }
+
+        /**
+         * Set a point in the multilinestring geometry opened with
+         * add_linestring().
+         *
+         * @param p The point.
+         *
+         * @throws geometry_exception if the point set is the same as the
+         *         previous point. This would create zero-length segments
+         *         which are not allowed according to the vector tile spec.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_linestring(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void set_point(const point p) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(m_pbf_geometry.valid() &&
+                          "call add_linestring() before set_point()");
+            vtzero_assert(!m_pbf_tags.valid() &&
+                          "set_point() has to be called before properties are added");
+            m_num_points.decrement();
+            if (m_start_line) {
+                m_pbf_geometry.add_element(detail::command_move_to(1));
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.x - m_cursor.x));
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.y - m_cursor.y));
+                m_pbf_geometry.add_element(detail::command_line_to(m_num_points.value()));
+                m_start_line = false;
+            } else {
+                if (p == m_cursor) {
+                    throw geometry_exception{"Zero-length segments in linestrings are not allowed."};
+                }
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.x - m_cursor.x));
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.y - m_cursor.y));
+            }
+            m_cursor = p;
+        }
+
+        /**
+         * Set a point in the multilinestring geometry opened with
+         * add_linestring().
+         *
+         * @param x X coordinate of the point to set.
+         * @param y Y coordinate of the point to set.
+         *
+         * @throws geometry_exception if the point set is the same as the
+         *         previous point. This would create zero-length segments
+         *         which are not allowed according to the vector tile spec.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_linestring(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void set_point(const int32_t x, const int32_t y) {
+            set_point(point{x, y});
+        }
+
+        /**
+         * Set a point in the multilinestring geometry opened with
+         * add_linestring().
+         *
+         * @tparam TPoint A type that can be converted to vtzero::point using
+         *         the create_vtzero_point function.
+         * @param p The point to add.
+         *
+         * @throws geometry_exception if the point set is the same as the
+         *         previous point. This would create zero-length segments
+         *         which are not allowed according to the vector tile spec.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_linestring(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        template <typename TPoint>
+        void set_point(TPoint&& p) {
+            set_point(create_vtzero_point(std::forward<TPoint>(p)));
+        }
+
+        /**
+         * Add the points from the specified container as a linestring geometry
+         * to this feature.
+         *
+         * @tparam TContainer The container type. Must support the size()
+         *         method, be iterable using a range for loop, and contain
+         *         objects of type vtzero::point or something convertible to
+         *         it.
+         * @param container The container to read the points from.
+         *
+         * @throws geometry_exception If there are more than 2^32-1 members in
+         *         the container or if two consecutive points in the container
+         *         are identical.
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        template <typename TContainer>
+        void add_linestring_from_container(const TContainer& container) {
+            add_linestring(check_num_points(container.size()));
+            for (const auto& element : container) {
+                set_point(element);
+            }
+        }
+
+    }; // class linestring_feature_builder
+
+    /**
+     * Used for adding a feature with a (multi)polygon geometry to a layer.
+     * After creating an object of this class you can add data to the
+     * feature in a specific order:
+     *
+     * * Optionally add the ID using set_id().
+     * * Add the (multi)polygon geometry using add_ring() or
+     *   add_ring_from_container().
+     * * Optionally add any number of properties using add_property().
+     *
+     * @code
+     * vtzero::tile_builder tb;
+     * vtzero::layer_builder lb{tb};
+     * vtzero::polygon_feature_builder fb{lb};
+     * fb.set_id(123); // optionally set ID
+     * fb.add_ring(5);
+     * fb.set_point(10, 10);
+     * ...
+     * fb.add_property("foo", "bar"); // add property
+     * @endcode
+     */
+    class polygon_feature_builder : public feature_builder {
+
+        point m_first_point{0, 0};
+        bool m_start_ring = false;
+
+    public:
+
+        /**
+         * Constructor
+         *
+         * @param layer The layer we want to create this feature in.
+         */
+        explicit polygon_feature_builder(layer_builder layer) :
+            feature_builder(&layer.get_layer_impl()) {
+            m_feature_writer.add_enum(detail::pbf_feature::type, static_cast<int32_t>(GeomType::POLYGON));
+        }
+
+        /**
+         * Declare the intent to add a ring with *count* points to this
+         * feature.
+         *
+         * @param count The number of points in the ring.
+         *
+         * @pre @code count > 3 && count < 2^29 @endcode
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void add_ring(const uint32_t count) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(!m_pbf_tags.valid() &&
+                          "add_ring() has to be called before properties are added");
+            vtzero_assert(count > 3 && count < (1ul << 29u) && "add_ring() must be called with 3 < count < 2^29");
+            m_num_points.assert_is_zero();
+            if (!m_pbf_geometry.valid()) {
+                m_pbf_geometry = {m_feature_writer, detail::pbf_feature::geometry};
+            }
+            m_num_points.set(count);
+            m_start_ring = true;
+        }
+
+        /**
+         * Set a point in the ring opened with add_ring().
+         *
+         * @param p The point.
+         *
+         * @throws geometry_exception if the point set is the same as the
+         *         previous point. This would create zero-length segments
+         *         which are not allowed according to the vector tile spec.
+         *         This exception is also thrown when the last point in the
+         *         ring is not equal to the first point, because this would
+         *         not create a closed ring.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_ring(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void set_point(const point p) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(m_pbf_geometry.valid() &&
+                          "call add_ring() before set_point()");
+            vtzero_assert(!m_pbf_tags.valid() &&
+                          "set_point() has to be called before properties are added");
+            m_num_points.decrement();
+            if (m_start_ring) {
+                m_first_point = p;
+                m_pbf_geometry.add_element(detail::command_move_to(1));
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.x - m_cursor.x));
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.y - m_cursor.y));
+                m_pbf_geometry.add_element(detail::command_line_to(m_num_points.value() - 1));
+                m_start_ring = false;
+                m_cursor = p;
+            } else if (m_num_points.value() == 0) {
+                if (p != m_first_point) {
+                    throw geometry_exception{"Last point in a ring must be the same as the first point."};
+                }
+                // spec 4.3.3.3 "A ClosePath command MUST have a command count of 1"
+                m_pbf_geometry.add_element(detail::command_close_path());
+            } else {
+                if (p == m_cursor) {
+                    throw geometry_exception{"Zero-length segments in linestrings are not allowed."};
+                }
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.x - m_cursor.x));
+                m_pbf_geometry.add_element(protozero::encode_zigzag32(p.y - m_cursor.y));
+                m_cursor = p;
+            }
+        }
+
+        /**
+         * Set a point in the ring opened with add_ring().
+         *
+         * @param x X coordinate of the point to set.
+         * @param y Y coordinate of the point to set.
+         *
+         * @throws geometry_exception if the point set is the same as the
+         *         previous point. This would create zero-length segments
+         *         which are not allowed according to the vector tile spec.
+         *         This exception is also thrown when the last point in the
+         *         ring is not equal to the first point, because this would
+         *         not create a closed ring.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_ring(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void set_point(const int32_t x, const int32_t y) {
+            set_point(point{x, y});
+        }
+
+        /**
+         * Set a point in the ring opened with add_ring().
+         *
+         * @tparam TPoint A type that can be converted to vtzero::point using
+         *         the create_vtzero_point function.
+         * @param p The point to add.
+         *
+         * @throws geometry_exception if the point set is the same as the
+         *         previous point. This would create zero-length segments
+         *         which are not allowed according to the vector tile spec.
+         *         This exception is also thrown when the last point in the
+         *         ring is not equal to the first point, because this would
+         *         not create a closed ring.
+         *
+         * @pre There must have been less than *count* calls to set_point()
+         *      already after a call to add_ring(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        template <typename TPoint>
+        void set_point(TPoint&& p) {
+            set_point(create_vtzero_point(std::forward<TPoint>(p)));
+        }
+
+        /**
+         * Close a ring opened with add_ring(). This can be called for the
+         * last point (which will be equal to the first point) in the ring
+         * instead of calling set_point().
+         *
+         * @pre There must have been *count* - 1 calls to set_point()
+         *      already after a call to add_ring(count).
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        void close_ring() {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(m_pbf_geometry.valid() &&
+                          "Call add_ring() before you can call close_ring()");
+            vtzero_assert(!m_pbf_tags.valid() &&
+                          "close_ring() has to be called before properties are added");
+            vtzero_assert(m_num_points.value() == 1 &&
+                          "wrong number of points in ring");
+            m_pbf_geometry.add_element(detail::command_close_path());
+            m_num_points.decrement();
+        }
+
+        /**
+         * Add the points from the specified container as a ring to this
+         * feature.
+         *
+         * @tparam TContainer The container type. Must support the size()
+         *         method, be iterable using a range for loop, and contain
+         *         objects of type vtzero::point or something convertible to
+         *         it.
+         * @param container The container to read the points from.
+         *
+         * @throws geometry_exception If there are more than 2^32-1 members in
+         *         the container or if two consecutive points in the container
+         *         are identical or if the last point is not the same as the
+         *         first point.
+         *
+         * @pre You must not have any calls to add_property() before calling
+         *      this method.
+         */
+        template <typename TContainer>
+        void add_ring_from_container(const TContainer& container) {
+            add_ring(check_num_points(container.size()));
+            for (const auto& element : container) {
+                set_point(element);
+            }
+        }
+
+    }; // class polygon_feature_builder
+
+    /**
+     * Used for adding a feature to a layer using an existing geometry. After
+     * creating an object of this class you can add data to the feature in a
+     * specific order:
+     *
+     * * Optionally add the ID using set_id().
+     * * Add the geometry using set_geometry().
+     * * Optionally add any number of properties using add_property().
+     *
+     * @code
+     * auto geom = ... // get geometry from a feature you are reading
+     * ...
+     * vtzero::tile_builder tb;
+     * vtzero::layer_builder lb{tb};
+     * vtzero::geometry_feature_builder fb{lb};
+     * fb.set_id(123); // optionally set ID
+     * fb.set_geometry(geom) // add geometry
+     * fb.add_property("foo", "bar"); // add property
+     * @endcode
+     */
+    class geometry_feature_builder : public detail::feature_builder_base {
+
+    public:
+
+        /**
+         * Constructor
+         *
+         * @param layer The layer we want to create this feature in.
+         */
+        explicit geometry_feature_builder(layer_builder layer) :
+            feature_builder_base(&layer.get_layer_impl()) {
+        }
+
+        /**
+         * If the feature was not committed, the destructor will roll back all
+         * the changes.
+         */
+        ~geometry_feature_builder() noexcept {
+            try {
+                rollback();
+            } catch (...) {
+                // ignore exceptions
+            }
+        }
+
+        /// Feature builders can not be copied.
+        geometry_feature_builder(const geometry_feature_builder&) = delete;
+
+        /// Feature builders can not be copied.
+        geometry_feature_builder& operator=(const geometry_feature_builder&) = delete;
+
+        /// Feature builders can be moved.
+        geometry_feature_builder(geometry_feature_builder&&) noexcept = default;
+
+        /// Feature builders can be moved.
+        geometry_feature_builder& operator=(geometry_feature_builder&&) noexcept = default;
+
+        /**
+         * Set the ID of this feature.
+         *
+         * You can only call this function once and it must be before calling
+         * set_geometry().
+         *
+         * @param id The ID.
+         */
+        void set_id(uint64_t id) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not call set_id() after commit() or rollback()");
+            vtzero_assert(!m_pbf_tags.valid());
+            m_feature_writer.add_uint64(detail::pbf_feature::id, id);
+        }
+
+        /**
+         * Set the geometry of this feature.
+         *
+         * You can only call this method once and it must be before calling the
+         * add_property() method.
+         *
+         * @param geometry The geometry.
+         */
+        void set_geometry(const geometry& geometry) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not add geometry after commit() or rollback()");
+            vtzero_assert(!m_pbf_tags.valid());
+            m_feature_writer.add_enum(detail::pbf_feature::type, static_cast<int32_t>(geometry.type()));
+            m_feature_writer.add_string(detail::pbf_feature::geometry, geometry.data());
+            m_pbf_tags = {m_feature_writer, detail::pbf_feature::tags};
+        }
+
+        /**
+         * Add a property to this feature. Can only be called after the
+         * set_geometry method.
+         *
+         * @tparam TProp Can be type index_value_pair or property.
+         * @param prop The property to add.
+         */
+        template <typename TProp>
+        void add_property(TProp&& prop) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not call add_property() after commit() or rollback()");
+            add_property_impl(std::forward<TProp>(prop));
+        }
+
+        /**
+         * Add a property to this feature. Can only be called after the
+         * set_geometry method.
+         *
+         * @tparam TKey Can be type index_value or data_view or anything that
+         *         converts to it.
+         * @tparam TValue Can be type index_value or property_value or
+         *         encoded_property or anything that converts to it.
+         * @param key The key.
+         * @param value The value.
+         */
+        template <typename TKey, typename TValue>
+        void add_property(TKey&& key, TValue&& value) {
+            vtzero_assert(m_feature_writer.valid() &&
+                          "Can not call add_property() after commit() or rollback()");
+            add_property_impl(std::forward<TKey>(key), std::forward<TValue>(value));
+        }
+
+        /**
+         * Commit this feature. Call this after all the details of this
+         * feature have been added. If this is not called, the feature
+         * will be rolled back when the destructor of the feature_builder is
+         * called.
+         *
+         * Once a feature has been committed or rolled back, further calls
+         * to commit() or rollback() don't do anything.
+         */
+        void commit() {
+            if (m_feature_writer.valid()) {
+                vtzero_assert(m_pbf_tags.valid() &&
+                              "Can not call commit before geometry was added");
+                do_commit();
+            }
+        }
+
+        /**
+         * Rollback this feature. Removed all traces of this feature from
+         * the layer_builder. Useful when you started creating a feature
+         * but then find out that its geometry is invalid or something like
+         * it. This will also happen automatically when the feature_builder
+         * is destructed and commit() hasn't been called on it.
+         *
+         * Once a feature has been committed or rolled back, further calls
+         * to commit() or rollback() don't do anything.
+         */
+        void rollback() {
+            if (m_feature_writer.valid()) {
+                do_rollback();
+            }
+        }
+
+    }; // class geometry_feature_builder
+
+    inline void layer_builder::add_feature(const feature& feature) {
+        geometry_feature_builder feature_builder{*this};
+        if (feature.has_id()) {
+            feature_builder.set_id(feature.id());
+        }
+        feature_builder.set_geometry(feature.geometry());
+        feature.for_each_property([&feature_builder](const property& p) {
+            feature_builder.add_property(p);
+            return true;
+        });
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_BUILDER_HPP
diff --git a/third_party/vtzero/include/vtzero/builder_impl.hpp b/third_party/vtzero/include/vtzero/builder_impl.hpp
new file mode 100644
index 00000000000..95db484d25f
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/builder_impl.hpp
@@ -0,0 +1,274 @@
+#ifndef VTZERO_BUILDER_IMPL_HPP
+#define VTZERO_BUILDER_IMPL_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file builder_impl.hpp
+ *
+ * @brief Contains classes internal to the builder.
+ */
+
+#include "encoded_property_value.hpp"
+#include "property_value.hpp"
+#include "types.hpp"
+
+#include <protozero/pbf_builder.hpp>
+#include <protozero/pbf_message.hpp>
+
+#include <cstdlib>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace vtzero {
+
+    namespace detail {
+
+        class layer_builder_base {
+
+        public:
+
+            layer_builder_base() noexcept = default;
+
+            virtual ~layer_builder_base() noexcept = default;
+
+            layer_builder_base(const layer_builder_base&) noexcept = default;
+            layer_builder_base& operator=(const layer_builder_base&) noexcept = default;
+
+            layer_builder_base(layer_builder_base&&) noexcept = default;
+            layer_builder_base& operator=(layer_builder_base&&) noexcept = default;
+
+            virtual std::size_t estimated_size() const = 0;
+
+            virtual void build(protozero::pbf_builder<detail::pbf_tile>& pbf_tile_builder) const = 0;
+
+        }; // class layer_builder_base
+
+        class layer_builder_impl : public layer_builder_base {
+
+            // Buffer containing the encoded layer metadata and features
+            std::string m_data;
+
+            // Buffer containing the encoded keys table
+            std::string m_keys_data;
+
+            // Buffer containing the encoded values table
+            std::string m_values_data;
+
+            protozero::pbf_builder<detail::pbf_layer> m_pbf_message_layer;
+            protozero::pbf_builder<detail::pbf_layer> m_pbf_message_keys;
+            protozero::pbf_builder<detail::pbf_layer> m_pbf_message_values;
+
+            // The number of features in the layer
+            std::size_t m_num_features = 0;
+
+            // The number of keys in the keys table
+            uint32_t m_num_keys = 0;
+
+            // The number of values in the values table
+            uint32_t m_num_values = 0;
+
+            // Below this value, no index will be used to find entries in the
+            // key/value tables. This number is based on some initial
+            // benchmarking but probably needs some tuning.
+            // See also https://github.com/mapbox/vtzero/issues/30
+            static constexpr const uint32_t max_entries_flat = 20;
+
+            using map_type = std::unordered_map<std::string, index_value>;
+            map_type m_keys_index;
+            map_type m_values_index;
+
+            static index_value find_in_table(const data_view text, const std::string& data) {
+                uint32_t index = 0;
+                protozero::pbf_message<detail::pbf_layer> pbf_table{data};
+
+                while (pbf_table.next()) {
+                    const auto v = pbf_table.get_view();
+                    if (v == text) {
+                        return index_value{index};
+                    }
+                    ++index;
+                }
+
+                return index_value{};
+            }
+
+            // Read the key or value table and populate an index from its
+            // entries. This is done once the table becomes too large to do
+            // linear search in it.
+            static void populate_index(const std::string& data, map_type& map) {
+                uint32_t index = 0;
+                protozero::pbf_message<detail::pbf_layer> pbf_table{data};
+
+                while (pbf_table.next()) {
+                    map[pbf_table.get_string()] = index++;
+                }
+            }
+
+            index_value add_value_without_dup_check(const data_view text) {
+                m_pbf_message_values.add_string(detail::pbf_layer::values, text);
+                return m_num_values++;
+            }
+
+            index_value add_value(const data_view text) {
+                const auto index = find_in_values_table(text);
+                if (index.valid()) {
+                    return index;
+                }
+                return add_value_without_dup_check(text);
+            }
+
+            index_value find_in_keys_table(const data_view text) {
+                if (m_num_keys < max_entries_flat) {
+                    return find_in_table(text, m_keys_data);
+                }
+
+                if (m_keys_index.empty()) {
+                    populate_index(m_keys_data, m_keys_index);
+                }
+
+                auto& v = m_keys_index[std::string(text)];
+                if (!v.valid()) {
+                    v = add_key_without_dup_check(text);
+                }
+                return v;
+            }
+
+            index_value find_in_values_table(const data_view text) {
+                if (m_num_values < max_entries_flat) {
+                    return find_in_table(text, m_values_data);
+                }
+
+                if (m_values_index.empty()) {
+                    populate_index(m_values_data, m_values_index);
+                }
+
+                auto& v = m_values_index[std::string(text)];
+                if (!v.valid()) {
+                    v = add_value_without_dup_check(text);
+                }
+                return v;
+            }
+
+        public:
+
+            template <typename TString>
+            layer_builder_impl(TString&& name, uint32_t version, uint32_t extent) :
+                m_pbf_message_layer(m_data),
+                m_pbf_message_keys(m_keys_data),
+                m_pbf_message_values(m_values_data) {
+                m_pbf_message_layer.add_uint32(detail::pbf_layer::version, version);
+                m_pbf_message_layer.add_string(detail::pbf_layer::name, std::forward<TString>(name));
+                m_pbf_message_layer.add_uint32(detail::pbf_layer::extent, extent);
+            }
+
+            ~layer_builder_impl() noexcept override = default;
+
+            layer_builder_impl(const layer_builder_impl&) = delete;
+            layer_builder_impl& operator=(const layer_builder_impl&) = delete;
+
+            layer_builder_impl(layer_builder_impl&&) = default;
+            layer_builder_impl& operator=(layer_builder_impl&&) = default;
+
+            index_value add_key_without_dup_check(const data_view text) {
+                m_pbf_message_keys.add_string(detail::pbf_layer::keys, text);
+                return m_num_keys++;
+            }
+
+            index_value add_key(const data_view text) {
+                const auto index = find_in_keys_table(text);
+                if (index.valid()) {
+                    return index;
+                }
+                return add_key_without_dup_check(text);
+            }
+
+            index_value add_value_without_dup_check(const property_value value) {
+                return add_value_without_dup_check(value.data());
+            }
+
+            index_value add_value_without_dup_check(const encoded_property_value& value) {
+                return add_value_without_dup_check(value.data());
+            }
+
+            index_value add_value(const property_value value) {
+                return add_value(value.data());
+            }
+
+            index_value add_value(const encoded_property_value& value) {
+                return add_value(value.data());
+            }
+
+            const std::string& data() const noexcept {
+                return m_data;
+            }
+
+            const std::string& keys_data() const noexcept {
+                return m_keys_data;
+            }
+
+            const std::string& values_data() const noexcept {
+                return m_values_data;
+            }
+
+            protozero::pbf_builder<detail::pbf_layer>& message() noexcept {
+                return m_pbf_message_layer;
+            }
+
+            void increment_feature_count() noexcept {
+                ++m_num_features;
+            }
+
+            std::size_t estimated_size() const override {
+                constexpr const std::size_t estimated_overhead_for_pbf_encoding = 8;
+                return data().size() +
+                       keys_data().size() +
+                       values_data().size() +
+                       estimated_overhead_for_pbf_encoding;
+            }
+
+            void build(protozero::pbf_builder<detail::pbf_tile>& pbf_tile_builder) const override {
+                if (m_num_features > 0) {
+                    pbf_tile_builder.add_bytes_vectored(detail::pbf_tile::layers,
+                                                        data(),
+                                                        keys_data(),
+                                                        values_data());
+                }
+            }
+
+        }; // class layer_builder_impl
+
+        class layer_builder_existing : public layer_builder_base {
+
+            data_view m_data;
+
+        public:
+
+            explicit layer_builder_existing(const data_view data) :
+                m_data(data) {
+            }
+
+            std::size_t estimated_size() const override {
+                constexpr const std::size_t estimated_overhead_for_pbf_encoding = 8;
+                return m_data.size() + estimated_overhead_for_pbf_encoding;
+            }
+
+            void build(protozero::pbf_builder<detail::pbf_tile>& pbf_tile_builder) const override {
+                pbf_tile_builder.add_bytes(detail::pbf_tile::layers, m_data);
+            }
+
+        }; // class layer_builder_existing
+
+    } // namespace detail
+
+} // namespace vtzero
+
+#endif // VTZERO_BUILDER_IMPL_HPP
diff --git a/third_party/vtzero/include/vtzero/encoded_property_value.hpp b/third_party/vtzero/include/vtzero/encoded_property_value.hpp
new file mode 100644
index 00000000000..8a573f3ed23
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/encoded_property_value.hpp
@@ -0,0 +1,244 @@
+#ifndef VTZERO_ENCODED_PROPERTY_VALUE_HPP
+#define VTZERO_ENCODED_PROPERTY_VALUE_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file encoded_property_value.hpp
+ *
+ * @brief Contains the encoded_property_value class.
+ */
+
+#include "types.hpp"
+
+#include <protozero/pbf_builder.hpp>
+
+#include <functional>
+#include <string>
+
+namespace vtzero {
+
+    /**
+     * A property value encoded in the vector_tile internal format. Can be
+     * created from values of many different types and then later added to
+     * a layer/feature.
+     */
+    class encoded_property_value {
+
+        std::string m_data;
+
+    public:
+
+        /// Construct from vtzero::string_value_type.
+        explicit encoded_property_value(string_value_type value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_string(detail::pbf_value::string_value, value.value);
+        }
+
+        /// Construct from const char*.
+        explicit encoded_property_value(const char* value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_string(detail::pbf_value::string_value, value);
+        }
+
+        /// Construct from const char* and size_t.
+        explicit encoded_property_value(const char* value, std::size_t size) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_string(detail::pbf_value::string_value, value, size);
+        }
+
+        /// Construct from std::string.
+        explicit encoded_property_value(const std::string& value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_string(detail::pbf_value::string_value, value);
+        }
+
+        /// Construct from vtzero::data_view.
+        explicit encoded_property_value(const data_view& value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_string(detail::pbf_value::string_value, value);
+        }
+
+        // ------------------
+
+        /// Construct from vtzero::float_value_type.
+        explicit encoded_property_value(float_value_type value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_float(detail::pbf_value::float_value, value.value);
+        }
+
+        /// Construct from float.
+        explicit encoded_property_value(float value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_float(detail::pbf_value::float_value, value);
+        }
+
+        // ------------------
+
+        /// Construct from vtzero::double_value_type.
+        explicit encoded_property_value(double_value_type value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_double(detail::pbf_value::double_value, value.value);
+        }
+
+        /// Construct from double.
+        explicit encoded_property_value(double value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_double(detail::pbf_value::double_value, value);
+        }
+
+        // ------------------
+
+        /// Construct from vtzero::int_value_type.
+        explicit encoded_property_value(int_value_type value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_int64(detail::pbf_value::int_value, value.value);
+        }
+
+        /// Construct from int64_t.
+        explicit encoded_property_value(int64_t value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_int64(detail::pbf_value::int_value, value);
+        }
+
+        /// Construct from int32_t.
+        explicit encoded_property_value(int32_t value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_int64(detail::pbf_value::int_value, static_cast<int64_t>(value));
+        }
+
+        /// Construct from int16_t.
+        explicit encoded_property_value(int16_t value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_int64(detail::pbf_value::int_value, static_cast<int64_t>(value));
+        }
+
+        // ------------------
+
+        /// Construct from vtzero::uint_value_type.
+        explicit encoded_property_value(uint_value_type value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_uint64(detail::pbf_value::uint_value, value.value);
+        }
+
+        /// Construct from uint64_t.
+        explicit encoded_property_value(uint64_t value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_uint64(detail::pbf_value::uint_value, value);
+        }
+
+        /// Construct from uint32_t.
+        explicit encoded_property_value(uint32_t value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_uint64(detail::pbf_value::uint_value, static_cast<uint64_t>(value));
+        }
+
+        /// Construct from uint16_t.
+        explicit encoded_property_value(uint16_t value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_uint64(detail::pbf_value::uint_value, static_cast<uint64_t>(value));
+        }
+
+        // ------------------
+
+        /// Construct from vtzero::sint_value_type.
+        explicit encoded_property_value(sint_value_type value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_sint64(detail::pbf_value::sint_value, value.value);
+        }
+
+        // ------------------
+
+        /// Construct from vtzero::bool_value_type.
+        explicit encoded_property_value(bool_value_type value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_bool(detail::pbf_value::bool_value, value.value);
+        }
+
+        /// Construct from bool.
+        explicit encoded_property_value(bool value) {
+            protozero::pbf_builder<detail::pbf_value> pbf_message_value{m_data};
+            pbf_message_value.add_bool(detail::pbf_value::bool_value, value);
+        }
+
+        // ------------------
+
+        /**
+         * Get view of the raw data stored inside.
+         */
+        data_view data() const noexcept {
+            return {m_data.data(), m_data.size()};
+        }
+
+        /**
+         * Hash function compatible with std::hash.
+         */
+        std::size_t hash() const noexcept {
+            return std::hash<std::string>{}(m_data);
+        }
+
+    }; // class encoded_property_value
+
+    /// Encoded property values are equal if they contain the same data.
+    inline bool operator==(const encoded_property_value& lhs, const encoded_property_value& rhs) noexcept {
+        return lhs.data() == rhs.data();
+    }
+
+    /// Encoded property values are unequal if they are not equal.
+    inline bool operator!=(const encoded_property_value& lhs, const encoded_property_value& rhs) noexcept {
+        return !(lhs == rhs);
+    }
+
+    /// Arbitrary ordering based on internal data.
+    inline bool operator<(const encoded_property_value& lhs, const encoded_property_value& rhs) noexcept {
+        return lhs.data() < rhs.data();
+    }
+
+    /// Arbitrary ordering based on internal data.
+    inline bool operator<=(const encoded_property_value& lhs, const encoded_property_value& rhs) noexcept {
+        return lhs.data() <= rhs.data();
+    }
+
+    /// Arbitrary ordering based on internal data.
+    inline bool operator>(const encoded_property_value& lhs, const encoded_property_value& rhs) noexcept {
+        return lhs.data() > rhs.data();
+    }
+
+    /// Arbitrary ordering based on internal data.
+    inline bool operator>=(const encoded_property_value& lhs, const encoded_property_value& rhs) noexcept {
+        return lhs.data() >= rhs.data();
+    }
+
+} // namespace vtzero
+
+namespace std {
+
+    /**
+     * Specialization of std::hash for encoded_property_value.
+     */
+    template <>
+    struct hash<vtzero::encoded_property_value> {
+
+        /// key vtzero::encoded_property_value
+        using argument_type = vtzero::encoded_property_value;
+
+        /// hash result: size_t
+        using result_type = std::size_t;
+
+        /// calculate the hash of the argument
+        std::size_t operator()(const vtzero::encoded_property_value& value) const noexcept {
+            return value.hash();
+        }
+
+    }; // struct hash
+
+} // namespace std
+
+#endif // VTZERO_ENCODED_PROPERTY_VALUE_HPP
diff --git a/third_party/vtzero/include/vtzero/exception.hpp b/third_party/vtzero/include/vtzero/exception.hpp
new file mode 100644
index 00000000000..80b7259541a
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/exception.hpp
@@ -0,0 +1,134 @@
+#ifndef VTZERO_EXCEPTION_HPP
+#define VTZERO_EXCEPTION_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file exception.hpp
+ *
+ * @brief Contains the exceptions used in the vtzero library.
+ */
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+
+namespace vtzero {
+
+    /**
+     * Base class for all exceptions directly thrown by the vtzero library.
+     */
+    class exception : public std::runtime_error {
+
+    public:
+
+        /// Constructor
+        explicit exception(const char* message) :
+            std::runtime_error(message) {
+        }
+
+        /// Constructor
+        explicit exception(const std::string& message) :
+            std::runtime_error(message) {
+        }
+
+    }; // class exception
+
+    /**
+     * This exception is thrown when vector tile encoding isn't valid according
+     * to the vector tile specification.
+     */
+    class format_exception : public exception {
+
+    public:
+
+        /// Constructor
+        explicit format_exception(const char* message) :
+            exception(message) {
+        }
+
+        /// Constructor
+        explicit format_exception(const std::string& message) :
+            exception(message) {
+        }
+
+    }; // class format_exception
+
+    /**
+     * This exception is thrown when a geometry encoding isn't valid according
+     * to the vector tile specification.
+     */
+    class geometry_exception : public format_exception {
+
+    public:
+
+        /// Constructor
+        explicit geometry_exception(const char* message) :
+            format_exception(message) {
+        }
+
+        /// Constructor
+        explicit geometry_exception(const std::string& message) :
+            format_exception(message) {
+        }
+
+    }; // class geometry_exception
+
+    /**
+     * This exception is thrown when a property value is accessed using the
+     * wrong type.
+     */
+    class type_exception : public exception {
+
+    public:
+
+        /// Constructor
+        explicit type_exception() :
+            exception("wrong property value type") {
+        }
+
+    }; // class type_exception
+
+    /**
+     * This exception is thrown when an unknown version number is found in the
+     * layer.
+     */
+    class version_exception : public exception {
+
+    public:
+
+        /// Constructor
+        explicit version_exception(const uint32_t version) :
+            exception(std::string{"unknown vector tile version: "} +
+                      std::to_string(version)) {
+        }
+
+    }; // version_exception
+
+    /**
+     * This exception is thrown when an index into the key or value table
+     * in a layer is out of range. This can only happen if the tile data is
+     * invalid.
+     */
+    class out_of_range_exception : public exception {
+
+    public:
+
+        /// Constructor
+        explicit out_of_range_exception(const uint32_t index) :
+            exception(std::string{"index out of range: "} +
+                      std::to_string(index)) {
+        }
+
+    }; // out_of_range_exception
+
+} // namespace vtzero
+
+#endif // VTZERO_EXCEPTION_HPP
diff --git a/third_party/vtzero/include/vtzero/feature.hpp b/third_party/vtzero/include/vtzero/feature.hpp
new file mode 100644
index 00000000000..504f155f773
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/feature.hpp
@@ -0,0 +1,302 @@
+#ifndef VTZERO_FEATURE_HPP
+#define VTZERO_FEATURE_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file feature.hpp
+ *
+ * @brief Contains the feature class.
+ */
+
+#include "exception.hpp"
+#include "property.hpp"
+#include "property_value.hpp"
+#include "types.hpp"
+
+#include <protozero/pbf_message.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <utility>
+
+namespace vtzero {
+
+    class layer;
+
+    /**
+     * A feature according to spec 4.2.
+     *
+     * Note that a feature will internally contain a pointer to the layer it
+     * came from. The layer has to stay valid as long as the feature is used.
+     */
+    class feature {
+
+        using uint32_it_range = protozero::iterator_range<protozero::pbf_reader::const_uint32_iterator>;
+
+        const layer* m_layer = nullptr;
+        uint64_t m_id = 0; // defaults to 0, see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/vector_tile.proto#L32
+        uint32_it_range m_properties{};
+        protozero::pbf_reader::const_uint32_iterator m_property_iterator{};
+        std::size_t m_num_properties = 0;
+        data_view m_geometry{};
+        GeomType m_geometry_type = GeomType::UNKNOWN; // defaults to UNKNOWN, see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/vector_tile.proto#L41
+        bool m_has_id = false;
+
+    public:
+
+        /**
+         * Construct an invalid feature object.
+         */
+        feature() = default;
+
+        /**
+         * Construct a feature object.
+         *
+         * @throws format_exception if the layer data is ill-formed.
+         */
+        feature(const layer* layer, const data_view data) :
+            m_layer(layer) {
+            vtzero_assert(layer);
+            vtzero_assert(data.data());
+
+            protozero::pbf_message<detail::pbf_feature> reader{data};
+
+            while (reader.next()) {
+                switch (reader.tag_and_type()) {
+                    case protozero::tag_and_type(detail::pbf_feature::id, protozero::pbf_wire_type::varint):
+                        m_id = reader.get_uint64();
+                        m_has_id = true;
+                        break;
+                    case protozero::tag_and_type(detail::pbf_feature::tags, protozero::pbf_wire_type::length_delimited):
+                        if (m_properties.begin() != protozero::pbf_reader::const_uint32_iterator{}) {
+                            throw format_exception{"Feature has more than one tags field"};
+                        }
+                        m_properties = reader.get_packed_uint32();
+                        m_property_iterator = m_properties.begin();
+                        break;
+                    case protozero::tag_and_type(detail::pbf_feature::type, protozero::pbf_wire_type::varint): {
+                            const auto type = reader.get_enum();
+                            // spec 4.3.4 "Geometry Types"
+                            if (type < 0 || type > 3) {
+                                throw format_exception{"Unknown geometry type (spec 4.3.4)"};
+                            }
+                            m_geometry_type = static_cast<GeomType>(type);
+                        }
+                        break;
+                    case protozero::tag_and_type(detail::pbf_feature::geometry, protozero::pbf_wire_type::length_delimited):
+                        if (!m_geometry.empty()) {
+                            throw format_exception{"Feature has more than one geometry field"};
+                        }
+                        m_geometry = reader.get_view();
+                        break;
+                    default:
+                        reader.skip(); // ignore unknown fields
+                }
+            }
+
+            // spec 4.2 "A feature MUST contain a geometry field."
+            if (m_geometry.empty()) {
+                throw format_exception{"Missing geometry field in feature (spec 4.2)"};
+            }
+
+            const auto size = m_properties.size();
+            if (size % 2 != 0) {
+                throw format_exception{"unpaired property key/value indexes (spec 4.4)"};
+            }
+            m_num_properties = size / 2;
+        }
+
+        /**
+         * Is this a valid feature? Valid features are those not created from
+         * the default constructor.
+         *
+         * Complexity: Constant.
+         */
+        bool valid() const noexcept {
+            return m_geometry.data() != nullptr;
+        }
+
+        /**
+         * Is this a valid feature? Valid features are those not created from
+         * the default constructor.
+         *
+         * Complexity: Constant.
+         */
+        explicit operator bool() const noexcept {
+            return valid();
+        }
+
+        /**
+         * The ID of this feature. According to the spec IDs should be unique
+         * in a layer if they are set (spec 4.2).
+         *
+         * Complexity: Constant.
+         *
+         * Always returns 0 for invalid features.
+         */
+        uint64_t id() const noexcept {
+            return m_id;
+        }
+
+        /**
+         * Does this feature have an ID?
+         *
+         * Complexity: Constant.
+         *
+         * Always returns false for invalid features.
+         */
+        bool has_id() const noexcept {
+            return m_has_id;
+        }
+
+        /**
+         * The geometry type of this feature.
+         *
+         * Complexity: Constant.
+         *
+         * Always returns GeomType::UNKNOWN for invalid features.
+         */
+        GeomType geometry_type() const noexcept {
+            return m_geometry_type;
+        }
+
+        /**
+         * Get the geometry of this feature.
+         *
+         * Complexity: Constant.
+         *
+         * @pre @code valid() @endcode
+         */
+        vtzero::geometry geometry() const noexcept {
+            vtzero_assert_in_noexcept_function(valid());
+            return {m_geometry, m_geometry_type};
+        }
+
+        /**
+         * Returns true if this feature doesn't have any properties.
+         *
+         * Complexity: Constant.
+         *
+         * Always returns true for invalid features.
+         */
+        bool empty() const noexcept {
+            return m_num_properties == 0;
+        }
+
+        /**
+         * Returns the number of properties in this feature.
+         *
+         * Complexity: Constant.
+         *
+         * Always returns 0 for invalid features.
+         */
+        std::size_t num_properties() const noexcept {
+            return m_num_properties;
+        }
+
+        /**
+         * Get the next property in this feature.
+         *
+         * Complexity: Constant.
+         *
+         * @returns The next property or the invalid property if there are no
+         *          more properties.
+         * @throws format_exception if the feature data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         * @pre @code valid() @endcode
+         */
+        property next_property();
+
+        /**
+         * Get the indexes into the key/value table for the next property in
+         * this feature.
+         *
+         * Complexity: Constant.
+         *
+         * @returns The next index_value_pair or an invalid index_value_pair
+         *          if there are no more properties.
+         * @throws format_exception if the feature data is ill-formed.
+         * @throws out_of_range_exception if the key or value index is not
+         *         within the range of indexes in the layer key/value table.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         * @pre @code valid() @endcode
+         */
+        index_value_pair next_property_indexes();
+
+        /**
+         * Reset the property iterator. The next time next_property() or
+         * next_property_indexes() is called, it will begin from the first
+         * property again.
+         *
+         * Complexity: Constant.
+         *
+         * @pre @code valid() @endcode
+         */
+        void reset_property() noexcept {
+            vtzero_assert_in_noexcept_function(valid());
+            m_property_iterator = m_properties.begin();
+        }
+
+        /**
+         * Call a function for each property of this feature.
+         *
+         * @tparam TFunc The type of the function. It must take a single
+         *         argument of type property&& and return a bool. If the
+         *         function returns false, the iteration will be stopped.
+         * @param func The function to call.
+         * @returns true if the iteration was completed and false otherwise.
+         * @pre @code valid() @endcode
+         */
+        template <typename TFunc>
+        bool for_each_property(TFunc&& func) const;
+
+    }; // class feature
+
+    /**
+     * Create some kind of mapping from property keys to property values.
+     *
+     * This can be used to read all properties into a std::map or similar
+     * object.
+     *
+     * @tparam TMap Map type (std::map, std::unordered_map, ...) Must support
+     *              the emplace() method.
+     * @tparam TKey Key type, usually the key of the map type. The data_view
+     *              of the property key is converted to this type before
+     *              adding it to the map.
+     * @tparam TValue Value type, usally the value of the map type. The
+     *                property_value is converted to this type before
+     *                adding it to the map.
+     * @tparam TMapping A struct derived from property_value_mapping with the
+     *         mapping for vtzero property value types to TValue-constructing
+     *         types. (See convert_property_value() for details.)
+     * @param feature The feature to get the properties from.
+     * @returns An object of type TMap with all the properties.
+     * @pre @code feature.valid() @endcode
+     */
+    template <typename TMap,
+              typename TKey = typename TMap::key_type,
+              typename TValue = typename TMap::mapped_type,
+              typename TMapping = property_value_mapping>
+    TMap create_properties_map(const vtzero::feature& feature) {
+        TMap map;
+
+        feature.for_each_property([&map](const property& p) {
+            map.emplace(TKey(p.key()), convert_property_value<TValue, TMapping>(p.value()));
+            return true;
+        });
+
+        return map;
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_FEATURE_HPP
diff --git a/third_party/vtzero/include/vtzero/feature_builder_impl.hpp b/third_party/vtzero/include/vtzero/feature_builder_impl.hpp
new file mode 100644
index 00000000000..761a795791e
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/feature_builder_impl.hpp
@@ -0,0 +1,118 @@
+#ifndef VTZERO_FEATURE_BUILDER_IMPL_HPP
+#define VTZERO_FEATURE_BUILDER_IMPL_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file feature_builder_impl.hpp
+ *
+ * @brief Contains classes internal to the builder.
+ */
+
+#include "builder_impl.hpp"
+#include "encoded_property_value.hpp"
+#include "geometry.hpp"
+#include "property.hpp"
+#include "property_value.hpp"
+
+#include <utility>
+
+namespace vtzero {
+
+    namespace detail {
+
+        class feature_builder_base {
+
+            layer_builder_impl* m_layer;
+
+            void add_key_internal(index_value idx) {
+                vtzero_assert(idx.valid());
+                m_pbf_tags.add_element(idx.value());
+            }
+
+            template <typename T>
+            void add_key_internal(T&& key) {
+                add_key_internal(m_layer->add_key(data_view{std::forward<T>(key)}));
+            }
+
+            void add_value_internal(index_value idx) {
+                vtzero_assert(idx.valid());
+                m_pbf_tags.add_element(idx.value());
+            }
+
+            void add_value_internal(property_value value) {
+                add_value_internal(m_layer->add_value(value));
+            }
+
+            template <typename T>
+            void add_value_internal(T&& value) {
+                encoded_property_value v{std::forward<T>(value)};
+                add_value_internal(m_layer->add_value(v));
+            }
+
+        protected:
+
+            protozero::pbf_builder<detail::pbf_feature> m_feature_writer;
+            protozero::packed_field_uint32 m_pbf_tags;
+
+            explicit feature_builder_base(layer_builder_impl* layer) :
+                m_layer(layer),
+                m_feature_writer(layer->message(), detail::pbf_layer::features) {
+            }
+
+            ~feature_builder_base() noexcept = default;
+
+            feature_builder_base(const feature_builder_base&) = delete; // NOLINT(hicpp-use-equals-delete, modernize-use-equals-delete)
+
+            feature_builder_base& operator=(const feature_builder_base&) = delete; // NOLINT(hicpp-use-equals-delete, modernize-use-equals-delete)
+                                                                                   // The check wants these functions to be public...
+
+            feature_builder_base(feature_builder_base&&) noexcept = default;
+
+            feature_builder_base& operator=(feature_builder_base&&) noexcept = default;
+
+            void add_property_impl(const property& property) {
+                add_key_internal(property.key());
+                add_value_internal(property.value());
+            }
+
+            void add_property_impl(const index_value_pair idxs) {
+                add_key_internal(idxs.key());
+                add_value_internal(idxs.value());
+            }
+
+            template <typename TKey, typename TValue>
+            void add_property_impl(TKey&& key, TValue&& value) {
+                add_key_internal(std::forward<TKey>(key));
+                add_value_internal(std::forward<TValue>(value));
+            }
+
+            void do_commit() {
+                if (m_pbf_tags.valid()) {
+                    m_pbf_tags.commit();
+                }
+                m_feature_writer.commit();
+                m_layer->increment_feature_count();
+            }
+
+            void do_rollback() {
+                if (m_pbf_tags.valid()) {
+                    m_pbf_tags.rollback();
+                }
+                m_feature_writer.rollback();
+            }
+
+        }; // class feature_builder_base
+
+    } // namespace detail
+
+} // namespace vtzero
+
+#endif // VTZERO_FEATURE_BUILDER_IMPL_HPP
diff --git a/third_party/vtzero/include/vtzero/geometry.hpp b/third_party/vtzero/include/vtzero/geometry.hpp
new file mode 100644
index 00000000000..c505feb3e35
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/geometry.hpp
@@ -0,0 +1,444 @@
+#ifndef VTZERO_GEOMETRY_HPP
+#define VTZERO_GEOMETRY_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file geometry.hpp
+ *
+ * @brief Contains classes and functions related to geometry handling.
+ */
+
+#include "exception.hpp"
+#include "types.hpp"
+
+#include <protozero/pbf_reader.hpp>
+
+#include <cstdint>
+#include <limits>
+#include <utility>
+
+namespace vtzero {
+
+    /// A simple point class
+    struct point {
+
+        /// X coordinate
+        int32_t x = 0;
+
+        /// Y coordinate
+        int32_t y = 0;
+
+        /// Default construct to 0 coordinates
+        constexpr point() noexcept = default;
+
+        /// Constructor
+        constexpr point(int32_t x_, int32_t y_) noexcept :
+            x(x_),
+            y(y_) {
+        }
+
+    }; // struct point
+
+    /**
+     * Type of a polygon ring. This can either be "outer", "inner", or
+     * "invalid". Invalid is used when the area of the ring is 0.
+     */
+    enum class ring_type {
+        outer = 0,
+        inner = 1,
+        invalid = 2
+    }; // enum class ring_type
+
+    /**
+     * Helper function to create a point from any type that has members x
+     * and y.
+     *
+     * If your point type doesn't have members x any y, you can overload this
+     * function for your type and it will be used by vtzero.
+     */
+    template <typename TPoint>
+    point create_vtzero_point(const TPoint& p) noexcept {
+        return {p.x, p.y};
+    }
+
+    /// Points are equal if their coordinates are
+    inline constexpr bool operator==(const point a, const point b) noexcept {
+        return a.x == b.x && a.y == b.y;
+    }
+
+    /// Points are not equal if their coordinates aren't
+    inline constexpr bool operator!=(const point a, const point b) noexcept {
+        return !(a == b);
+    }
+
+    namespace detail {
+
+        /// The command id type as specified in the vector tile spec
+        enum class CommandId : uint32_t {
+            MOVE_TO = 1,
+            LINE_TO = 2,
+            CLOSE_PATH = 7
+        };
+
+        inline constexpr uint32_t command_integer(CommandId id, const uint32_t count) noexcept {
+            return (static_cast<uint32_t>(id) & 0x7u) | (count << 3u);
+        }
+
+        inline constexpr uint32_t command_move_to(const uint32_t count) noexcept {
+            return command_integer(CommandId::MOVE_TO, count);
+        }
+
+        inline constexpr uint32_t command_line_to(const uint32_t count) noexcept {
+            return command_integer(CommandId::LINE_TO, count);
+        }
+
+        inline constexpr uint32_t command_close_path() noexcept {
+            return command_integer(CommandId::CLOSE_PATH, 1);
+        }
+
+        inline constexpr uint32_t get_command_id(const uint32_t command_integer) noexcept {
+            return command_integer & 0x7u;
+        }
+
+        inline constexpr uint32_t get_command_count(const uint32_t command_integer) noexcept {
+            return command_integer >> 3u;
+        }
+
+        // The maximum value for the command count according to the spec.
+        inline constexpr uint32_t max_command_count() noexcept {
+            return get_command_count(std::numeric_limits<uint32_t>::max());
+        }
+
+        inline constexpr int64_t det(const point a, const point b) noexcept {
+            return static_cast<int64_t>(a.x) * static_cast<int64_t>(b.y) -
+                   static_cast<int64_t>(b.x) * static_cast<int64_t>(a.y);
+        }
+
+        template <typename T, typename Enable = void>
+        struct get_result {
+
+            using type = void;
+
+            template <typename TGeomHandler>
+            void operator()(TGeomHandler&& /*geom_handler*/) const noexcept {
+            }
+
+        };
+
+        template <typename T>
+        struct get_result<T, typename std::enable_if<!std::is_same<decltype(std::declval<T>().result()), void>::value>::type> {
+
+            using type = decltype(std::declval<T>().result());
+
+            template <typename TGeomHandler>
+            type operator()(TGeomHandler&& geom_handler) {
+                return std::forward<TGeomHandler>(geom_handler).result();
+            }
+
+        };
+
+        /**
+         * Decode a geometry as specified in spec 4.3 from a sequence of 32 bit
+         * unsigned integers. This templated base class can be instantiated
+         * with a different iterator type for testing than for normal use.
+         */
+        template <typename TIterator>
+        class geometry_decoder {
+
+        public:
+
+            using iterator_type = TIterator;
+
+        private:
+
+            iterator_type m_it;
+            iterator_type m_end;
+
+            point m_cursor{0, 0};
+
+            // maximum value for m_count before we throw an exception
+            uint32_t m_max_count;
+
+            /**
+             * The current count value is set from the CommandInteger and
+             * then counted down with each next_point() call. So it must be
+             * greater than 0 when next_point() is called and 0 when
+             * next_command() is called.
+             */
+            uint32_t m_count = 0;
+
+        public:
+
+            geometry_decoder(iterator_type begin, iterator_type end, std::size_t max) :
+                m_it(begin),
+                m_end(end),
+                m_max_count(static_cast<uint32_t>(max)) {
+                vtzero_assert(max <= detail::max_command_count());
+            }
+
+            uint32_t count() const noexcept {
+                return m_count;
+            }
+
+            bool done() const noexcept {
+                return m_it == m_end;
+            }
+
+            bool next_command(const CommandId expected_command_id) {
+                vtzero_assert(m_count == 0);
+
+                if (m_it == m_end) {
+                    return false;
+                }
+
+                const auto command_id = get_command_id(*m_it);
+                if (command_id != static_cast<uint32_t>(expected_command_id)) {
+                    throw geometry_exception{std::string{"expected command "} +
+                                             std::to_string(static_cast<uint32_t>(expected_command_id)) +
+                                             " but got " +
+                                             std::to_string(command_id)};
+                }
+
+                if (expected_command_id == CommandId::CLOSE_PATH) {
+                    // spec 4.3.3.3 "A ClosePath command MUST have a command count of 1"
+                    if (get_command_count(*m_it) != 1) {
+                        throw geometry_exception{"ClosePath command count is not 1"};
+                    }
+                } else {
+                    m_count = get_command_count(*m_it);
+                    if (m_count > m_max_count) {
+                        throw geometry_exception{"count too large"};
+                    }
+                }
+
+                ++m_it;
+
+                return true;
+            }
+
+            point next_point() {
+                vtzero_assert(m_count > 0);
+
+                if (m_it == m_end || std::next(m_it) == m_end) {
+                    throw geometry_exception{"too few points in geometry"};
+                }
+
+                // spec 4.3.2 "A ParameterInteger is zigzag encoded"
+                int64_t x = protozero::decode_zigzag32(*m_it++);
+                int64_t y = protozero::decode_zigzag32(*m_it++);
+
+                // x and y are int64_t so this addition can never overflow
+                x += m_cursor.x;
+                y += m_cursor.y;
+
+                // The cast is okay, because a valid vector tile can never
+                // contain values that would overflow here and we don't care
+                // what happens to invalid tiles here.
+                m_cursor.x = static_cast<int32_t>(x);
+                m_cursor.y = static_cast<int32_t>(y);
+
+                --m_count;
+
+                return m_cursor;
+            }
+
+            template <typename TGeomHandler>
+            typename detail::get_result<TGeomHandler>::type decode_point(TGeomHandler&& geom_handler) {
+                // spec 4.3.4.2 "MUST consist of a single MoveTo command"
+                if (!next_command(CommandId::MOVE_TO)) {
+                    throw geometry_exception{"expected MoveTo command (spec 4.3.4.2)"};
+                }
+
+                // spec 4.3.4.2 "command count greater than 0"
+                if (count() == 0) {
+                    throw geometry_exception{"MoveTo command count is zero (spec 4.3.4.2)"};
+                }
+
+                std::forward<TGeomHandler>(geom_handler).points_begin(count());
+                while (count() > 0) {
+                    std::forward<TGeomHandler>(geom_handler).points_point(next_point());
+                }
+
+                // spec 4.3.4.2 "MUST consist of of a single ... command"
+                if (!done()) {
+                    throw geometry_exception{"additional data after end of geometry (spec 4.3.4.2)"};
+                }
+
+                std::forward<TGeomHandler>(geom_handler).points_end();
+
+                return detail::get_result<TGeomHandler>{}(std::forward<TGeomHandler>(geom_handler));
+            }
+
+            template <typename TGeomHandler>
+            typename detail::get_result<TGeomHandler>::type decode_linestring(TGeomHandler&& geom_handler) {
+                // spec 4.3.4.3 "1. A MoveTo command"
+                while (next_command(CommandId::MOVE_TO)) {
+                    // spec 4.3.4.3 "with a command count of 1"
+                    if (count() != 1) {
+                        throw geometry_exception{"MoveTo command count is not 1 (spec 4.3.4.3)"};
+                    }
+
+                    const auto first_point = next_point();
+
+                    // spec 4.3.4.3 "2. A LineTo command"
+                    if (!next_command(CommandId::LINE_TO)) {
+                        throw geometry_exception{"expected LineTo command (spec 4.3.4.3)"};
+                    }
+
+                    // spec 4.3.4.3 "with a command count greater than 0"
+                    if (count() == 0) {
+                        throw geometry_exception{"LineTo command count is zero (spec 4.3.4.3)"};
+                    }
+
+                    std::forward<TGeomHandler>(geom_handler).linestring_begin(count() + 1);
+
+                    std::forward<TGeomHandler>(geom_handler).linestring_point(first_point);
+                    while (count() > 0) {
+                        std::forward<TGeomHandler>(geom_handler).linestring_point(next_point());
+                    }
+
+                    std::forward<TGeomHandler>(geom_handler).linestring_end();
+                }
+
+                return detail::get_result<TGeomHandler>{}(std::forward<TGeomHandler>(geom_handler));
+            }
+
+            template <typename TGeomHandler>
+            typename detail::get_result<TGeomHandler>::type decode_polygon(TGeomHandler&& geom_handler) {
+                // spec 4.3.4.4 "1. A MoveTo command"
+                while (next_command(CommandId::MOVE_TO)) {
+                    // spec 4.3.4.4 "with a command count of 1"
+                    if (count() != 1) {
+                        throw geometry_exception{"MoveTo command count is not 1 (spec 4.3.4.4)"};
+                    }
+
+                    int64_t sum = 0;
+                    const point start_point = next_point();
+                    point last_point = start_point;
+
+                    // spec 4.3.4.4 "2. A LineTo command"
+                    if (!next_command(CommandId::LINE_TO)) {
+                        throw geometry_exception{"expected LineTo command (spec 4.3.4.4)"};
+                    }
+
+                    std::forward<TGeomHandler>(geom_handler).ring_begin(count() + 2);
+
+                    std::forward<TGeomHandler>(geom_handler).ring_point(start_point);
+
+                    while (count() > 0) {
+                        const point p = next_point();
+                        sum += detail::det(last_point, p);
+                        last_point = p;
+                        std::forward<TGeomHandler>(geom_handler).ring_point(p);
+                    }
+
+                    // spec 4.3.4.4 "3. A ClosePath command"
+                    if (!next_command(CommandId::CLOSE_PATH)) {
+                        throw geometry_exception{"expected ClosePath command (4.3.4.4)"};
+                    }
+
+                    sum += detail::det(last_point, start_point);
+
+                    std::forward<TGeomHandler>(geom_handler).ring_point(start_point);
+
+                    std::forward<TGeomHandler>(geom_handler).ring_end(sum > 0 ? ring_type::outer :
+                                                                      sum < 0 ? ring_type::inner : ring_type::invalid);
+                }
+
+                return detail::get_result<TGeomHandler>{}(std::forward<TGeomHandler>(geom_handler));
+            }
+
+        }; // class geometry_decoder
+
+    } // namespace detail
+
+    /**
+     * Decode a point geometry.
+     *
+     * @tparam TGeomHandler Handler class. See tutorial for details.
+     * @param geometry The geometry as returned by feature.geometry().
+     * @param geom_handler An object of TGeomHandler.
+     * @throws geometry_error If there is a problem with the geometry.
+     * @pre Geometry must be a point geometry.
+     */
+    template <typename TGeomHandler>
+    typename detail::get_result<TGeomHandler>::type decode_point_geometry(const geometry& geometry, TGeomHandler&& geom_handler) {
+        vtzero_assert(geometry.type() == GeomType::POINT);
+        detail::geometry_decoder<decltype(geometry.begin())> decoder{geometry.begin(), geometry.end(), geometry.data().size() / 2};
+        return decoder.decode_point(std::forward<TGeomHandler>(geom_handler));
+    }
+
+    /**
+     * Decode a linestring geometry.
+     *
+     * @tparam TGeomHandler Handler class. See tutorial for details.
+     * @param geometry The geometry as returned by feature.geometry().
+     * @param geom_handler An object of TGeomHandler.
+     * @returns whatever geom_handler.result() returns if that function exists,
+     *          void otherwise
+     * @throws geometry_error If there is a problem with the geometry.
+     * @pre Geometry must be a linestring geometry.
+     */
+    template <typename TGeomHandler>
+    typename detail::get_result<TGeomHandler>::type decode_linestring_geometry(const geometry& geometry, TGeomHandler&& geom_handler) {
+        vtzero_assert(geometry.type() == GeomType::LINESTRING);
+        detail::geometry_decoder<decltype(geometry.begin())> decoder{geometry.begin(), geometry.end(), geometry.data().size() / 2};
+        return decoder.decode_linestring(std::forward<TGeomHandler>(geom_handler));
+    }
+
+    /**
+     * Decode a polygon geometry.
+     *
+     * @tparam TGeomHandler Handler class. See tutorial for details.
+     * @param geometry The geometry as returned by feature.geometry().
+     * @param geom_handler An object of TGeomHandler.
+     * @returns whatever geom_handler.result() returns if that function exists,
+     *          void otherwise
+     * @throws geometry_error If there is a problem with the geometry.
+     * @pre Geometry must be a polygon geometry.
+     */
+    template <typename TGeomHandler>
+    typename detail::get_result<TGeomHandler>::type decode_polygon_geometry(const geometry& geometry, TGeomHandler&& geom_handler) {
+        vtzero_assert(geometry.type() == GeomType::POLYGON);
+        detail::geometry_decoder<decltype(geometry.begin())> decoder{geometry.begin(), geometry.end(), geometry.data().size() / 2};
+        return decoder.decode_polygon(std::forward<TGeomHandler>(geom_handler));
+    }
+
+    /**
+     * Decode a geometry.
+     *
+     * @tparam TGeomHandler Handler class. See tutorial for details.
+     * @param geometry The geometry as returned by feature.geometry().
+     * @param geom_handler An object of TGeomHandler.
+     * @returns whatever geom_handler.result() returns if that function exists,
+     *          void otherwise
+     * @throws geometry_error If the geometry has type UNKNOWN of if there is
+     *                        a problem with the geometry.
+     */
+    template <typename TGeomHandler>
+    typename detail::get_result<TGeomHandler>::type decode_geometry(const geometry& geometry, TGeomHandler&& geom_handler) {
+        detail::geometry_decoder<decltype(geometry.begin())> decoder{geometry.begin(), geometry.end(), geometry.data().size() / 2};
+        switch (geometry.type()) {
+            case GeomType::POINT:
+                return decoder.decode_point(std::forward<TGeomHandler>(geom_handler));
+            case GeomType::LINESTRING:
+                return decoder.decode_linestring(std::forward<TGeomHandler>(geom_handler));
+            case GeomType::POLYGON:
+                return decoder.decode_polygon(std::forward<TGeomHandler>(geom_handler));
+            default:
+                break;
+        }
+        throw geometry_exception{"unknown geometry type"};
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_GEOMETRY_HPP
diff --git a/third_party/vtzero/include/vtzero/index.hpp b/third_party/vtzero/include/vtzero/index.hpp
new file mode 100644
index 00000000000..75f4df73937
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/index.hpp
@@ -0,0 +1,264 @@
+#ifndef VTZERO_INDEX_HPP
+#define VTZERO_INDEX_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file index.hpp
+ *
+ * @brief Contains classes for indexing the key/value tables inside layers.
+ */
+
+#include "builder.hpp"
+#include "types.hpp"
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+namespace vtzero {
+
+    /**
+     * Used to store the mapping between property keys and the index value
+     * in the table stored in a layer.
+     *
+     * @tparam TMap The map class to use (std::map, std::unordered_map or
+     *         something compatible).
+     */
+    template <template <typename...> class TMap>
+    class key_index {
+
+        layer_builder& m_builder;
+
+        TMap<std::string, index_value> m_index;
+
+    public:
+
+        /**
+         * Construct index.
+         *
+         * @param builder The layer we are building containing the key table
+         *        we are creating the index for.
+         */
+        explicit key_index(layer_builder& builder) :
+            m_builder(builder) {
+        }
+
+        /**
+         * Get the index value for the specified key. If the key was not in
+         * the table, it will be added.
+         *
+         * @param key The key to store.
+         * @returns The index value of they key.
+         */
+        index_value operator()(const data_view key) {
+            std::string text(key);
+            const auto it = m_index.find(text);
+            if (it == m_index.end()) {
+                const auto idx = m_builder.add_key_without_dup_check(key);
+                m_index.emplace(std::move(text), idx);
+                return idx;
+            }
+            return it->second;
+        }
+
+    }; // class key_index
+
+    /**
+     * Used to store the mapping between property values and the index value
+     * in the table stored in a layer. Stores the values in their original
+     * form (as type TExternal) which is more efficient than the way
+     * value_index_internal does it, but you need an instance of this class
+     * for each value type you use.
+     *
+     * @tparam TInternal The type used in the vector tile to encode the value.
+     *         Must be one of string/float/double/int/uint/sint/bool_value_type.
+     * @tparam TExternal The type for the value used by the user of this class.
+     * @tparam TMap The map class to use (std::map, std::unordered_map or
+     *         something compatible).
+     */
+    template <typename TInternal, typename TExternal, template <typename...> class TMap>
+    class value_index {
+
+        layer_builder& m_builder;
+
+        TMap<TExternal, index_value> m_index;
+
+    public:
+
+        /**
+         * Construct index.
+         *
+         * @param builder The layer we are building containing the value
+         *        table we are creating the index for.
+         */
+        explicit value_index(layer_builder& builder) :
+            m_builder(builder) {
+        }
+
+        /**
+         * Get the index value for the specified value. If the value was not in
+         * the table, it will be added.
+         *
+         * @param value The value to store.
+         * @returns The index value of they value.
+         */
+        index_value operator()(const TExternal& value) {
+            const auto it = m_index.find(value);
+            if (it == m_index.end()) {
+                const auto idx = m_builder.add_value_without_dup_check(encoded_property_value{TInternal{value}});
+                m_index.emplace(value, idx);
+                return idx;
+            }
+            return it->second;
+        }
+
+    }; // class value_index
+
+    /**
+     * Used to store the mapping between bool property values and the index
+     * value in the table stored in a layer.
+     *
+     * This is the most efficient index if you know that your property values
+     * are bools.
+     */
+    class value_index_bool {
+
+        layer_builder& m_builder;
+
+        std::array<index_value, 2> m_index;
+
+    public:
+
+        /**
+         * Construct index.
+         *
+         * @param builder The layer we are building containing the value
+         *        table we are creating the index for.
+         */
+        explicit value_index_bool(layer_builder& builder) :
+            m_builder(builder) {
+        }
+
+        /**
+         * Get the index value for the specified value. If the value was not in
+         * the table, it will be added.
+         *
+         * @param value The value to store.
+         * @returns The index value of they value.
+         */
+        index_value operator()(const bool value) {
+            auto& idx = m_index[static_cast<std::size_t>(value)]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+            if (!idx.valid()) {
+                idx = m_builder.add_value_without_dup_check(encoded_property_value{value});
+            }
+            return idx;
+        }
+
+    }; // class value_index_bool
+
+    /**
+     * Used to store the mapping between small unsigned int property values and
+     * the index value in the table stored in a layer.
+     *
+     * This is the most efficient index if you know that your property values
+     * are densly used small unsigned integers. This is usually the case for
+     * enums.
+     *
+     * Interally a simple vector<index_value> is used and the value is used
+     * as is to look up the index value in the vector.
+     */
+    class value_index_small_uint {
+
+        layer_builder& m_builder;
+
+        std::vector<index_value> m_index;
+
+    public:
+
+        /**
+         * Construct index.
+         *
+         * @param builder The layer we are building containing the value
+         *        table we are creating the index for.
+         */
+        explicit value_index_small_uint(layer_builder& builder) :
+            m_builder(builder) {
+        }
+
+        /**
+         * Get the index value for the specified value. If the value was not in
+         * the table, it will be added.
+         *
+         * @param value The value to store.
+         * @returns The index value of they value.
+         */
+        index_value operator()(const uint16_t value) {
+            if (value >= m_index.size()) {
+                m_index.resize(value + 1);
+            }
+            if (!m_index[value].valid()) {
+                m_index[value] = m_builder.add_value_without_dup_check(encoded_property_value{value});
+            }
+            return m_index[value];
+        }
+
+    }; // class value_index_small_uint
+
+    /**
+     * Used to store the mapping between property values and the index value
+     * in the table stored in a layer. Stores the values in the already
+     * encoded form. This is simpler to use than the value_index class, but
+     * has a higher overhead.
+     *
+     * @tparam TMap The map class to use (std::map, std::unordered_map or
+     *         something compatible).
+     */
+    template <template <typename...> class TMap>
+    class value_index_internal {
+
+        layer_builder& m_builder;
+
+        TMap<encoded_property_value, index_value> m_index;
+
+    public:
+
+        /**
+         * Construct index.
+         *
+         * @param builder The layer we are building containing the value
+         *        table we are creating the index for.
+         */
+        explicit value_index_internal(layer_builder& builder) :
+            m_builder(builder) {
+        }
+
+        /**
+         * Get the index value for the specified value. If the value was not in
+         * the table, it will be added.
+         *
+         * @param value The value to store.
+         * @returns The index value of they value.
+         */
+        index_value operator()(const encoded_property_value& value) {
+            const auto it = m_index.find(value);
+            if (it == m_index.end()) {
+                const auto idx = m_builder.add_value_without_dup_check(value);
+                m_index.emplace(value, idx);
+                return idx;
+            }
+            return it->second;
+        }
+
+    }; // class value_index_internal
+
+} // namespace vtzero
+
+#endif // VTZERO_INDEX_HPP
diff --git a/third_party/vtzero/include/vtzero/layer.hpp b/third_party/vtzero/include/vtzero/layer.hpp
new file mode 100644
index 00000000000..f5ca7f941a6
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/layer.hpp
@@ -0,0 +1,484 @@
+#ifndef VTZERO_LAYER_HPP
+#define VTZERO_LAYER_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file layer.hpp
+ *
+ * @brief Contains the layer class.
+ */
+
+#include "exception.hpp"
+#include "feature.hpp"
+#include "geometry.hpp"
+#include "property_value.hpp"
+#include "types.hpp"
+
+#include <protozero/pbf_message.hpp>
+
+#include <cstdint>
+#include <iterator>
+#include <vector>
+
+namespace vtzero {
+
+    /**
+     * A layer according to spec 4.1. It contains a version, the extent,
+     * and a name. For the most efficient way to access the features in this
+     * layer call next_feature() until it returns an invalid feature:
+     *
+     * @code
+     *   std::string data = ...;
+     *   vector_tile tile{data};
+     *   layer = tile.next_layer();
+     *   while (auto feature = layer.next_feature()) {
+     *     ...
+     *   }
+     * @endcode
+     *
+     * If you know the ID of a feature, you can get it directly with
+     * @code
+     *   layer.get_feature_by_id(7);
+     * @endcode
+     */
+    class layer {
+
+        data_view m_data{};
+        uint32_t m_version = 1; // defaults to 1, see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/vector_tile.proto#L55
+        uint32_t m_extent = 4096; // defaults to 4096, see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/vector_tile.proto#L70
+        std::size_t m_num_features = 0;
+        data_view m_name{};
+        protozero::pbf_message<detail::pbf_layer> m_layer_reader{m_data};
+        mutable std::vector<data_view> m_key_table;
+        mutable std::vector<property_value> m_value_table;
+        mutable std::size_t m_key_table_size = 0;
+        mutable std::size_t m_value_table_size = 0;
+
+        void initialize_tables() const {
+            m_key_table.reserve(m_key_table_size);
+            m_key_table_size = 0;
+
+            m_value_table.reserve(m_value_table_size);
+            m_value_table_size = 0;
+
+            protozero::pbf_message<detail::pbf_layer> reader{m_data};
+            while (reader.next()) {
+                switch (reader.tag_and_type()) {
+                    case protozero::tag_and_type(detail::pbf_layer::keys, protozero::pbf_wire_type::length_delimited):
+                        m_key_table.push_back(reader.get_view());
+                        break;
+                    case protozero::tag_and_type(detail::pbf_layer::values, protozero::pbf_wire_type::length_delimited):
+                        m_value_table.emplace_back(reader.get_view());
+                        break;
+                    default:
+                        reader.skip(); // ignore unknown fields
+                }
+            }
+        }
+
+    public:
+
+        /**
+         * Construct an invalid layer object.
+         */
+        layer() = default;
+
+        /**
+         * Construct a layer object. This is usually not something done in
+         * user code, because layers are created by the tile_iterator.
+         *
+         * @throws format_exception if the layer data is ill-formed.
+         * @throws version_exception if the layer contains an unsupported version
+         *                           number (only version 1 and 2 are supported)
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         */
+        explicit layer(const data_view data) :
+            m_data(data) {
+            protozero::pbf_message<detail::pbf_layer> reader{data};
+            while (reader.next()) {
+                switch (reader.tag_and_type()) {
+                    case protozero::tag_and_type(detail::pbf_layer::version, protozero::pbf_wire_type::varint):
+                        m_version = reader.get_uint32();
+                        break;
+                    case protozero::tag_and_type(detail::pbf_layer::name, protozero::pbf_wire_type::length_delimited):
+                        m_name = reader.get_view();
+                        break;
+                    case protozero::tag_and_type(detail::pbf_layer::features, protozero::pbf_wire_type::length_delimited):
+                        reader.skip(); // ignore features for now
+                        ++m_num_features;
+                        break;
+                    case protozero::tag_and_type(detail::pbf_layer::keys, protozero::pbf_wire_type::length_delimited):
+                        reader.skip();
+                        ++m_key_table_size;
+                        break;
+                    case protozero::tag_and_type(detail::pbf_layer::values, protozero::pbf_wire_type::length_delimited):
+                        reader.skip();
+                        ++m_value_table_size;
+                        break;
+                    case protozero::tag_and_type(detail::pbf_layer::extent, protozero::pbf_wire_type::varint):
+                        m_extent = reader.get_uint32();
+                        break;
+                    default:
+                        throw format_exception{"unknown field in layer (tag=" +
+                                               std::to_string(static_cast<uint32_t>(reader.tag())) +
+                                               ", type=" +
+                                               std::to_string(static_cast<uint32_t>(reader.wire_type())) +
+                                               ")"};
+                }
+            }
+
+            // This library can only handle version 1 and 2.
+            if (m_version < 1 || m_version > 2) {
+                throw version_exception{m_version};
+            }
+
+            // 4.1 "A layer MUST contain a name field."
+            if (m_name.data() == nullptr) {
+                throw format_exception{"missing name field in layer (spec 4.1)"};
+            }
+        }
+
+        /**
+         * Is this a valid layer? Valid layers are those not created from the
+         * default constructor.
+         */
+        bool valid() const noexcept {
+            return m_data.data() != nullptr;
+        }
+
+        /**
+         * Is this a valid layer? Valid layers are those not created from the
+         * default constructor.
+         */
+        explicit operator bool() const noexcept {
+            return valid();
+        }
+
+        /**
+         * Get a reference to the raw data this layer is created from.
+         */
+        data_view data() const noexcept {
+            return m_data;
+        }
+
+        /**
+         * Return the name of the layer.
+         *
+         * @pre @code valid() @endcode
+         */
+        data_view name() const noexcept {
+            vtzero_assert_in_noexcept_function(valid());
+
+            return m_name;
+        }
+
+        /**
+         * Return the version of this layer.
+         *
+         * @pre @code valid() @endcode
+         */
+        std::uint32_t version() const noexcept {
+            vtzero_assert_in_noexcept_function(valid());
+
+            return m_version;
+        }
+
+        /**
+         * Return the extent of this layer.
+         *
+         * @pre @code valid() @endcode
+         */
+        std::uint32_t extent() const noexcept {
+            vtzero_assert_in_noexcept_function(valid());
+
+            return m_extent;
+        }
+
+        /**
+         * Does this layer contain any features?
+         *
+         * Complexity: Constant.
+         */
+        bool empty() const noexcept {
+            return m_num_features == 0;
+        }
+
+        /**
+         * The number of features in this layer.
+         *
+         * Complexity: Constant.
+         */
+        std::size_t num_features() const noexcept {
+            return m_num_features;
+        }
+
+        /**
+         * Return a reference to the key table.
+         *
+         * Complexity: Amortized constant. First time the table is needed
+         *             it needs to be created.
+         *
+         * @pre @code valid() @endcode
+         */
+        const std::vector<data_view>& key_table() const {
+            vtzero_assert(valid());
+
+            if (m_key_table_size > 0) {
+                initialize_tables();
+            }
+            return m_key_table;
+        }
+
+        /**
+         * Return a reference to the value table.
+         *
+         * Complexity: Amortized constant. First time the table is needed
+         *             it needs to be created.
+         *
+         * @pre @code valid() @endcode
+         */
+        const std::vector<property_value>& value_table() const {
+            vtzero_assert(valid());
+
+            if (m_value_table_size > 0) {
+                initialize_tables();
+            }
+            return m_value_table;
+        }
+
+        /**
+         * Return the size of the key table. This returns the correct value
+         * whether the key table was already built or not.
+         *
+         * Complexity: Constant.
+         *
+         * @returns Size of the key table.
+         */
+        std::size_t key_table_size() const noexcept {
+            return m_key_table_size > 0 ? m_key_table_size : m_key_table.size();
+        }
+
+        /**
+         * Return the size of the value table. This returns the correct value
+         * whether the value table was already built or not.
+         *
+         * Complexity: Constant.
+         *
+         * @returns Size of the value table.
+         */
+        std::size_t value_table_size() const noexcept {
+            return m_value_table_size > 0 ? m_value_table_size : m_value_table.size();
+        }
+
+        /**
+         * Get the property key with the given index.
+         *
+         * Complexity: Amortized constant. First time the table is needed
+         *             it needs to be created.
+         *
+         * @throws out_of_range_exception if the index is out of range.
+         * @pre @code valid() @endcode
+         */
+        data_view key(index_value index) const {
+            vtzero_assert(valid());
+
+            const auto& table = key_table();
+            if (index.value() >= table.size()) {
+                throw out_of_range_exception{index.value()};
+            }
+
+            return table[index.value()];
+        }
+
+        /**
+         * Get the property value with the given index.
+         *
+         * Complexity: Amortized constant. First time the table is needed
+         *             it needs to be created.
+         *
+         * @throws out_of_range_exception if the index is out of range.
+         * @pre @code valid() @endcode
+         */
+        property_value value(index_value index) const {
+            vtzero_assert(valid());
+
+            const auto& table = value_table();
+            if (index.value() >= table.size()) {
+                throw out_of_range_exception{index.value()};
+            }
+
+            return table[index.value()];
+        }
+
+        /**
+         * Get the next feature in this layer.
+         *
+         * Note that the feature returned will internally contain a pointer to
+         * the layer it came from. The layer has to stay valid as long as the
+         * feature is used.
+         *
+         * Complexity: Constant.
+         *
+         * @returns The next feature or the invalid feature if there are no
+         *          more features.
+         * @throws format_exception if the layer data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         * @pre @code valid() @endcode
+         */
+        feature next_feature() {
+            vtzero_assert(valid());
+
+            const bool has_next = m_layer_reader.next(detail::pbf_layer::features,
+                                                      protozero::pbf_wire_type::length_delimited);
+
+            return has_next ? feature{this, m_layer_reader.get_view()} : feature{};
+        }
+
+        /**
+         * Reset the feature iterator. The next time next_feature() is called,
+         * it will begin from the first feature again.
+         *
+         * Complexity: Constant.
+         *
+         * @pre @code valid() @endcode
+         */
+        void reset_feature() noexcept {
+            vtzero_assert_in_noexcept_function(valid());
+
+            m_layer_reader = protozero::pbf_message<detail::pbf_layer>{m_data};
+        }
+
+        /**
+         * Call a function for each feature in this layer.
+         *
+         * @tparam The type of the function. It must take a single argument
+         *         of type feature&& and return a bool. If the function returns
+         *         false, the iteration will be stopped.
+         * @param func The function to call.
+         * @returns true if the iteration was completed and false otherwise.
+         * @pre @code valid() @endcode
+         */
+        template <typename TFunc>
+        bool for_each_feature(TFunc&& func) const {
+            vtzero_assert(valid());
+
+            protozero::pbf_message<detail::pbf_layer> layer_reader{m_data};
+            while (layer_reader.next(detail::pbf_layer::features,
+                                     protozero::pbf_wire_type::length_delimited)) {
+                if (!std::forward<TFunc>(func)(feature{this, layer_reader.get_view()})) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /**
+         * Get the feature with the specified ID. If there are several features
+         * with the same ID, it is undefined which one you'll get.
+         *
+         * Note that the feature returned will internally contain a pointer to
+         * the layer it came from. The layer has to stay valid as long as the
+         * feature is used.
+         *
+         * Complexity: Linear in the number of features.
+         *
+         * @param id The ID to look for.
+         * @returns Feature with the specified ID or the invalid feature if
+         *          there is no feature with this ID.
+         * @throws format_exception if the layer data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         * @pre @code valid() @endcode
+         */
+        feature get_feature_by_id(uint64_t id) const {
+            vtzero_assert(valid());
+
+            protozero::pbf_message<detail::pbf_layer> layer_reader{m_data};
+            while (layer_reader.next(detail::pbf_layer::features, protozero::pbf_wire_type::length_delimited)) {
+                const auto feature_data = layer_reader.get_view();
+                protozero::pbf_message<detail::pbf_feature> feature_reader{feature_data};
+                if (feature_reader.next(detail::pbf_feature::id, protozero::pbf_wire_type::varint)) {
+                    if (feature_reader.get_uint64() == id) {
+                        return feature{this, feature_data};
+                    }
+                }
+            }
+
+            return feature{};
+        }
+
+    }; // class layer
+
+    inline property feature::next_property() {
+        const auto idxs = next_property_indexes();
+        property p{};
+        if (idxs.valid()) {
+            p = {m_layer->key(idxs.key()),
+                 m_layer->value(idxs.value())};
+        }
+        return p;
+    }
+
+    inline index_value_pair feature::next_property_indexes() {
+        vtzero_assert(valid());
+        if (m_property_iterator == m_properties.end()) {
+            return {};
+        }
+
+        const auto ki = *m_property_iterator++;
+        if (!index_value{ki}.valid()) {
+            throw out_of_range_exception{ki};
+        }
+
+        assert(m_property_iterator != m_properties.end());
+        const auto vi = *m_property_iterator++;
+        if (!index_value{vi}.valid()) {
+            throw out_of_range_exception{vi};
+        }
+
+        if (ki >= m_layer->key_table_size()) {
+            throw out_of_range_exception{ki};
+        }
+
+        if (vi >= m_layer->value_table_size()) {
+            throw out_of_range_exception{vi};
+        }
+
+        return {ki, vi};
+    }
+
+    template <typename TFunc>
+    bool feature::for_each_property(TFunc&& func) const {
+        vtzero_assert(valid());
+
+        for (auto it = m_properties.begin(); it != m_properties.end();) {
+            const uint32_t ki = *it++;
+            if (!index_value{ki}.valid()) {
+                throw out_of_range_exception{ki};
+            }
+
+            assert(m_property_iterator != m_properties.end());
+            const uint32_t vi = *it++;
+            if (!index_value{vi}.valid()) {
+                throw out_of_range_exception{vi};
+            }
+
+            if (!std::forward<TFunc>(func)(property{m_layer->key(ki), m_layer->value(vi)})) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_LAYER_HPP
diff --git a/third_party/vtzero/include/vtzero/output.hpp b/third_party/vtzero/include/vtzero/output.hpp
new file mode 100644
index 00000000000..45f485eaf90
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/output.hpp
@@ -0,0 +1,64 @@
+#ifndef VTZERO_OUTPUT_HPP
+#define VTZERO_OUTPUT_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file output.hpp
+ *
+ * @brief Contains overloads of operator<< for basic vtzero types.
+ */
+
+#include <vtzero/geometry.hpp>
+#include <vtzero/types.hpp>
+
+#include <iosfwd>
+
+namespace vtzero {
+
+    /// Overload of the << operator for GeomType
+    template <typename TChar, typename TTraits>
+    std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const GeomType type) {
+        return out << geom_type_name(type);
+    }
+
+    /// Overload of the << operator for property_value_type
+    template <typename TChar, typename TTraits>
+    std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const property_value_type type) {
+        return out << property_value_type_name(type);
+    }
+
+    /// Overload of the << operator for index_value
+    template <typename TChar, typename TTraits>
+    std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const index_value index) {
+        if (index.valid()) {
+            return out << index.value();
+        }
+        return out << "invalid";
+    }
+
+    /// Overload of the << operator for index_value_pair
+    template <typename TChar, typename TTraits>
+    std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const index_value_pair index_pair) {
+        if (index_pair.valid()) {
+            return out << '[' << index_pair.key() << ',' << index_pair.value() << ']';
+        }
+        return out << "invalid";
+    }
+
+    /// Overload of the << operator for points
+    template <typename TChar, typename TTraits>
+    std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const point p) {
+        return out << '(' << p.x << ',' << p.y << ')';
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_OUTPUT_HPP
diff --git a/third_party/vtzero/include/vtzero/property.hpp b/third_party/vtzero/include/vtzero/property.hpp
new file mode 100644
index 00000000000..e00d722890f
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/property.hpp
@@ -0,0 +1,89 @@
+#ifndef VTZERO_PROPERTY_HPP
+#define VTZERO_PROPERTY_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file property.hpp
+ *
+ * @brief Contains the property class.
+ */
+
+#include "property_value.hpp"
+#include "types.hpp"
+
+namespace vtzero {
+
+    /**
+     * A view of a vector tile property (key and value).
+     *
+     * Doesn't hold any data itself, just views of the key and value.
+     */
+    class property {
+
+        data_view m_key{};
+        property_value m_value{};
+
+    public:
+
+        /**
+         * The default constructor creates an invalid (empty) property.
+         */
+        constexpr property() noexcept = default;
+
+        /**
+         * Create a (valid) property from a key and value.
+         */
+        constexpr property(const data_view key, const property_value value) noexcept :
+            m_key(key),
+            m_value(value) {
+        }
+
+        /**
+         * Is this a valid property? Properties are valid if they were
+         * constructed using the non-default constructor.
+         */
+        constexpr bool valid() const noexcept {
+            return m_key.data() != nullptr;
+        }
+
+        /**
+         * Is this a valid property? Properties are valid if they were
+         * constructed using the non-default constructor.
+         */
+        explicit constexpr operator bool() const noexcept {
+            return valid();
+        }
+
+        /// Return the property key.
+        constexpr data_view key() const noexcept {
+            return m_key;
+        }
+
+        /// Return the property value.
+        constexpr property_value value() const noexcept {
+            return m_value;
+        }
+
+    }; // class property
+
+    /// properties are equal if they contain the same key & value data.
+    inline constexpr bool operator==(const property& lhs, const property& rhs) noexcept {
+        return lhs.key() == rhs.key() && lhs.value() == rhs.value();
+    }
+
+    /// properties are unequal if they do not contain them same key and value data.
+    inline constexpr bool operator!=(const property& lhs, const property& rhs) noexcept {
+        return !(lhs == rhs);
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_PROPERTY_HPP
diff --git a/third_party/vtzero/include/vtzero/property_mapper.hpp b/third_party/vtzero/include/vtzero/property_mapper.hpp
new file mode 100644
index 00000000000..8f547a8db00
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/property_mapper.hpp
@@ -0,0 +1,103 @@
+#ifndef VTZERO_PROPERTY_MAPPER_HPP
+#define VTZERO_PROPERTY_MAPPER_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file property_mapper.hpp
+ *
+ * @brief Contains the property_mapper class.
+ */
+
+#include "builder.hpp"
+#include "layer.hpp"
+
+#include <vector>
+
+namespace vtzero {
+
+    /**
+     * Establishes a mapping between index values of properties of an existing
+     * layer and a new layer. Can be used when copying some features from an
+     * existing layer to a new layer.
+     */
+    class property_mapper {
+
+        const layer& m_layer;
+        layer_builder& m_layer_builder;
+
+        std::vector<index_value> m_keys;
+        std::vector<index_value> m_values;
+
+    public:
+
+        /**
+         * Construct the mapping between the specified layers
+         *
+         * @param layer The existing layer from which (some) properties will
+         *        be copied.
+         * @param layer_builder The new layer that is being created.
+         */
+        property_mapper(const layer& layer, layer_builder& layer_builder) :
+            m_layer(layer),
+            m_layer_builder(layer_builder) {
+            m_keys.resize(layer.key_table().size());
+            m_values.resize(layer.value_table().size());
+        }
+
+        /**
+         * Map the value index of a key.
+         *
+         * @param index The value index of the key in the existing table.
+         * @returns The value index of the same key in the new table.
+         */
+        index_value map_key(index_value index) {
+            auto& k = m_keys[index.value()];
+
+            if (!k.valid()) {
+                k = m_layer_builder.add_key_without_dup_check(m_layer.key(index));
+            }
+
+            return k;
+        }
+
+        /**
+         * Map the value index of a value.
+         *
+         * @param index The value index of the value in the existing table.
+         * @returns The value index of the same value in the new table.
+         */
+        index_value map_value(index_value index) {
+            auto& v = m_values[index.value()];
+
+            if (!v.valid()) {
+                v = m_layer_builder.add_value_without_dup_check(m_layer.value(index));
+            }
+
+            return v;
+        }
+
+        /**
+         * Map the value indexes of a key/value pair.
+         *
+         * @param idxs The value indexes of the key/value pair in the existing
+         *        table.
+         * @returns The value indexes of the same key/value pair in the new
+         *          table.
+         */
+        index_value_pair operator()(index_value_pair idxs) {
+            return {map_key(idxs.key()), map_value(idxs.value())};
+        }
+
+    }; // class property_mapper
+
+} // namespace vtzero
+
+#endif // VTZERO_PROPERTY_MAPPER_HPP
diff --git a/third_party/vtzero/include/vtzero/property_value.hpp b/third_party/vtzero/include/vtzero/property_value.hpp
new file mode 100644
index 00000000000..bedb82f2fa5
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/property_value.hpp
@@ -0,0 +1,398 @@
+#ifndef VTZERO_PROPERTY_VALUE_HPP
+#define VTZERO_PROPERTY_VALUE_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file property_value.hpp
+ *
+ * @brief Contains the property_value class.
+ */
+
+#include "exception.hpp"
+#include "types.hpp"
+
+#include <protozero/pbf_message.hpp>
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <utility>
+
+namespace vtzero {
+
+    /**
+     * A view of a vector tile property value.
+     *
+     * Doesn't hold any data itself.
+     */
+    class property_value {
+
+        data_view m_value{};
+
+        static bool check_tag_and_type(protozero::pbf_tag_type tag, protozero::pbf_wire_type type) noexcept {
+            static constexpr const std::array<protozero::pbf_wire_type, 7> types{{
+                string_value_type::wire_type,
+                float_value_type::wire_type,
+                double_value_type::wire_type,
+                int_value_type::wire_type,
+                uint_value_type::wire_type,
+                sint_value_type::wire_type,
+                bool_value_type::wire_type,
+            }};
+
+            if (tag < 1 || tag > types.size()) {
+                return false;
+            }
+
+            return types[tag - 1] == type; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+        }
+
+        static data_view get_value_impl(protozero::pbf_message<detail::pbf_value>& value_message, string_value_type /* dummy */) {
+            return value_message.get_view();
+        }
+
+        static float get_value_impl(protozero::pbf_message<detail::pbf_value>& value_message, float_value_type /* dummy */) {
+            return value_message.get_float();
+        }
+
+        static double get_value_impl(protozero::pbf_message<detail::pbf_value>& value_message, double_value_type /* dummy */) {
+            return value_message.get_double();
+        }
+
+        static int64_t get_value_impl(protozero::pbf_message<detail::pbf_value>& value_message, int_value_type /* dummy */) {
+            return value_message.get_int64();
+        }
+
+        static uint64_t get_value_impl(protozero::pbf_message<detail::pbf_value>& value_message, uint_value_type /* dummy */) {
+            return value_message.get_uint64();
+        }
+
+        static int64_t get_value_impl(protozero::pbf_message<detail::pbf_value>& value_message, sint_value_type /* dummy */) {
+            return value_message.get_sint64();
+        }
+
+        static bool get_value_impl(protozero::pbf_message<detail::pbf_value>& value_message, bool_value_type /* dummy */) {
+            return value_message.get_bool();
+        }
+
+        template <typename T>
+        typename T::type get_value() const {
+            vtzero_assert(valid());
+            protozero::pbf_message<detail::pbf_value> value_message{m_value};
+
+            typename T::type result{};
+            bool has_result = false;
+            while (value_message.next(T::pvtype, T::wire_type)) {
+                result = get_value_impl(value_message, T());
+                has_result = true;
+            }
+
+            if (has_result) {
+                return result;
+            }
+
+            throw type_exception{};
+        }
+
+    public:
+
+        /**
+         * The default constructor creates an invalid (empty) property_value.
+         */
+        constexpr property_value() noexcept = default;
+
+        /**
+         * Create a (valid) property_value from a data_view.
+         */
+        explicit constexpr property_value(const data_view value) noexcept :
+            m_value(value) {
+        }
+
+        /**
+         * Is this a valid property value? Property values are valid if they
+         * were constructed using the non-default constructor.
+         */
+        constexpr bool valid() const noexcept {
+            return m_value.data() != nullptr;
+        }
+
+        /**
+         * Get the type of this property.
+         *
+         * @pre @code valid() @endcode
+         * @throws format_exception if the encoding is invalid
+         */
+        property_value_type type() const {
+            vtzero_assert(valid());
+            protozero::pbf_message<detail::pbf_value> value_message{m_value};
+            if (value_message.next()) {
+                const auto tag_val = static_cast<protozero::pbf_tag_type>(value_message.tag());
+                if (!check_tag_and_type(tag_val, value_message.wire_type())) {
+                    throw format_exception{"illegal property value type"};
+                }
+                return value_message.tag();
+            }
+            throw format_exception{"missing tag value"};
+        }
+
+        /**
+         * Get the internal data_view this object was constructed with.
+         */
+        constexpr data_view data() const noexcept {
+            return m_value;
+        }
+
+        /**
+         * Get string value of this object.
+         *
+         * @pre @code valid() @endcode
+         * @throws type_exception if the type of this property value is
+         *                        something other than string.
+         */
+        data_view string_value() const {
+            return get_value<string_value_type>();
+        }
+
+        /**
+         * Get float value of this object.
+         *
+         * @pre @code valid() @endcode
+         * @throws type_exception if the type of this property value is
+         *                        something other than float.
+         */
+        float float_value() const {
+            return get_value<float_value_type>();
+        }
+
+        /**
+         * Get double value of this object.
+         *
+         * @pre @code valid() @endcode
+         * @throws type_exception if the type of this property value is
+         *                        something other than double.
+         */
+        double double_value() const {
+            return get_value<double_value_type>();
+        }
+
+        /**
+         * Get int value of this object.
+         *
+         * @pre @code valid() @endcode
+         * @throws type_exception if the type of this property value is
+         *                        something other than int.
+         */
+        std::int64_t int_value() const {
+            return get_value<int_value_type>();
+        }
+
+        /**
+         * Get uint value of this object.
+         *
+         * @pre @code valid() @endcode
+         * @throws type_exception if the type of this property value is
+         *                        something other than uint.
+         */
+        std::uint64_t uint_value() const {
+            return get_value<uint_value_type>();
+        }
+
+        /**
+         * Get sint value of this object.
+         *
+         * @pre @code valid() @endcode
+         * @throws type_exception if the type of this property value is
+         *                        something other than sint.
+         */
+        std::int64_t sint_value() const {
+            return get_value<sint_value_type>();
+        }
+
+        /**
+         * Get bool value of this object.
+         *
+         * @pre @code valid() @endcode
+         * @throws type_exception if the type of this property value is
+         *                        something other than bool.
+         */
+        bool bool_value() const {
+            return get_value<bool_value_type>();
+        }
+
+    }; // class property_value
+
+    /// property_values are equal if they contain the same data.
+    inline constexpr bool operator==(const property_value lhs, const property_value rhs) noexcept {
+        return lhs.data() == rhs.data();
+    }
+
+    /// property_values are unequal if they do not contain the same data.
+    inline constexpr bool operator!=(const property_value lhs, const property_value rhs) noexcept {
+        return lhs.data() != rhs.data();
+    }
+
+    /// property_values are ordered in the same way as the underlying data
+    inline bool operator<(const property_value lhs, const property_value rhs) noexcept {
+        return lhs.data() < rhs.data();
+    }
+
+    /// property_values are ordered in the same way as the underlying data
+    inline bool operator<=(const property_value lhs, const property_value rhs) noexcept {
+        return lhs.data() <= rhs.data();
+    }
+
+    /// property_values are ordered in the same way as the underlying data
+    inline bool operator>(const property_value lhs, const property_value rhs) noexcept {
+        return lhs.data() > rhs.data();
+    }
+
+    /// property_values are ordered in the same way as the underlying data
+    inline bool operator>=(const property_value lhs, const property_value rhs) noexcept {
+        return lhs.data() >= rhs.data();
+    }
+
+    /**
+     * Apply the value to a visitor.
+     *
+     * The visitor must have an overloaded call operator taking a single
+     * argument of each of the types data_view, float, double, int64_t,
+     * uint64_t, and bool. All call operators must return the same type which
+     * will be the return type of this function.
+     */
+    template <typename V>
+    decltype(std::declval<V>()(data_view{})) apply_visitor(V&& visitor, const property_value value) {
+        switch (value.type()) {
+            case property_value_type::string_value:
+                return std::forward<V>(visitor)(value.string_value());
+            case property_value_type::float_value:
+                return std::forward<V>(visitor)(value.float_value());
+            case property_value_type::double_value:
+                return std::forward<V>(visitor)(value.double_value());
+            case property_value_type::int_value:
+                return std::forward<V>(visitor)(value.int_value());
+            case property_value_type::uint_value:
+                return std::forward<V>(visitor)(value.uint_value());
+            case property_value_type::sint_value:
+                return std::forward<V>(visitor)(value.sint_value());
+            default: // case property_value_type::bool_value:
+                return std::forward<V>(visitor)(value.bool_value());
+        }
+    }
+
+    namespace detail {
+
+        template <typename TVariant, typename TMapping>
+        struct convert_visitor {
+
+            TVariant operator()(data_view value) const {
+                return TVariant(typename TMapping::string_type(value));
+            }
+
+            TVariant operator()(float value) const {
+                return TVariant(typename TMapping::float_type(value));
+            }
+
+            TVariant operator()(double value) const {
+                return TVariant(typename TMapping::double_type(value));
+            }
+
+            TVariant operator()(int64_t value) const {
+                return TVariant(typename TMapping::int_type(value));
+            }
+
+            TVariant operator()(uint64_t value) const {
+                return TVariant(typename TMapping::uint_type(value));
+            }
+
+            TVariant operator()(bool value) const {
+                return TVariant(typename TMapping::bool_type(value));
+            }
+
+        }; // struct convert_visitor
+
+    } // namespace detail
+
+    /**
+     * Default mapping between the different types of a property_value to
+     * the types needed for a variant. Derive from this class, overwrite
+     * the types you want and use that class as second template parameter
+     * in the convert_property_value class.
+     */
+    struct property_value_mapping {
+
+        /// mapping for string type
+        using string_type = std::string;
+
+        /// mapping for float type
+        using float_type = float;
+
+        /// mapping for double type
+        using double_type = double;
+
+        /// mapping for int type
+        using int_type = int64_t;
+
+        /// mapping for uint type
+        using uint_type = uint64_t;
+
+        /// mapping for bool type
+        using bool_type = bool;
+
+    }; // struct property_value_mapping
+
+    /**
+     * Convert a property_value to a different (usually variant-based)
+     * class.
+     *
+     * Usage: If you have a variant type like
+     *
+     * @code
+     *   using variant_type = boost::variant<std::string, float, double, int64_t, uint64_t, bool>;
+     * @endcode
+     *
+     * you can use
+     * @code
+     *   property_value x = ...;
+     *   auto v = convert_property_value<variant_type>(x);
+     * @endcode
+     *
+     * to convert the data.
+     *
+     * Usually your variant type has to support all of the following types:
+     * std::string, float, double, int64_t, uint64_t, and bool. If your type
+     * doesn't, you can add a second template parameter with a struct
+     * containing the mapping between the vtzero types and your types:
+     *
+     * @code
+     *   struct mapping : vtzero::property_value_mapping {
+     *     using float_type = double; // convert all floats to doubles
+     *     using bool_type = int; // convert all bools to ints
+     *     // use default types for the rest
+     *     // see the class vtzero::property_value_mapping for the defaults
+     *   };
+     *   property_value x = ...;
+     *   auto v = convert_property_value<variant_type, mapping>(x);
+     * @endcode
+     *
+     * @tparam TVariant The variant type to convert to.
+     * @tparam TMapping A struct derived from property_value_mapping with the
+     *         mapping for the types.
+     * @param value The property value to convert.
+     *
+     */
+    template <typename TVariant, typename TMapping = property_value_mapping>
+    TVariant convert_property_value(const property_value value) {
+        return apply_visitor(detail::convert_visitor<TVariant, TMapping>{}, value);
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_PROPERTY_VALUE_HPP
diff --git a/third_party/vtzero/include/vtzero/types.hpp b/third_party/vtzero/include/vtzero/types.hpp
new file mode 100644
index 00000000000..3fffb3db5a9
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/types.hpp
@@ -0,0 +1,429 @@
+#ifndef VTZERO_TYPES_HPP
+#define VTZERO_TYPES_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+#include <protozero/pbf_reader.hpp>
+
+#include <cassert>
+
+// @cond internal
+// Wrappers for assert() used for testing
+#ifndef vtzero_assert
+# define vtzero_assert(x) assert(x)
+#endif
+#ifndef vtzero_assert_in_noexcept_function
+# define vtzero_assert_in_noexcept_function(x) assert(x)
+#endif
+// @endcond
+
+/**
+ * @file types.hpp
+ *
+ * @brief Contains the declaration of low-level types.
+ */
+
+/**
+ * @brief All parts of the vtzero header-only library are in this namespace.
+ */
+namespace vtzero {
+
+    /**
+     * Using data_view class from protozero. See the protozero documentation
+     * on how to change this to use a different implementation.
+     * https://github.com/mapbox/protozero/blob/master/doc/advanced.md#protozero_use_view
+     */
+    using data_view = protozero::data_view;
+
+    // based on https://github.com/mapbox/vector-tile-spec/blob/master/2.1/vector_tile.proto
+
+    /// The geometry type as specified in the vector tile spec
+    enum class GeomType {
+        UNKNOWN    = 0,
+        POINT      = 1,
+        LINESTRING = 2,
+        POLYGON    = 3
+    };
+
+    /**
+     * Return the name of a GeomType (for debug output etc.)
+     */
+    inline const char* geom_type_name(GeomType type) noexcept {
+        static const char* names[] = {
+            "unknown", "point", "linestring", "polygon"
+        };
+        return names[static_cast<int>(type)]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+    }
+
+    /// The property value type as specified in the vector tile spec
+    enum class property_value_type : protozero::pbf_tag_type {
+        string_value = 1,
+        float_value  = 2,
+        double_value = 3,
+        int_value    = 4,
+        uint_value   = 5,
+        sint_value   = 6,
+        bool_value   = 7
+    };
+
+    /**
+     * Return the name of a property value type (for debug output etc.)
+     */
+    inline const char* property_value_type_name(property_value_type type) noexcept {
+        static const char* names[] = {
+            "", "string", "float", "double", "int", "uint", "sint", "bool"
+        };
+        return names[static_cast<int>(type)]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
+    }
+
+    namespace detail {
+
+        enum class pbf_tile : protozero::pbf_tag_type {
+            layers = 3
+        };
+
+        enum class pbf_layer : protozero::pbf_tag_type {
+            name     =  1,
+            features =  2,
+            keys     =  3,
+            values   =  4,
+            extent   =  5,
+            version  = 15
+        };
+
+        enum class pbf_feature : protozero::pbf_tag_type {
+            id       = 1,
+            tags     = 2,
+            type     = 3,
+            geometry = 4
+        };
+
+        using pbf_value = property_value_type;
+
+    } // namespace detail
+
+    /// property value type holding a reference to a string
+    struct string_value_type {
+
+        /// the underlying storage type
+        using type = data_view;
+
+        /// @cond internal
+        constexpr static const property_value_type pvtype = property_value_type::string_value;
+        constexpr static const protozero::pbf_wire_type wire_type = protozero::pbf_wire_type::length_delimited;
+        /// @endcond
+
+        /// value
+        data_view value{};
+
+        /// Construct empty string_value_type
+        constexpr string_value_type() noexcept = default;
+
+        /// Construct string_value_type
+        explicit constexpr string_value_type(data_view v) :
+            value(v) {
+        }
+
+    }; // struct string_value_type
+
+    /// property value type holding a float
+    struct float_value_type {
+
+        /// the underlying storage type
+        using type = float;
+
+        /// @cond internal
+        constexpr static const property_value_type pvtype = property_value_type::float_value;
+        constexpr static const protozero::pbf_wire_type wire_type = protozero::pbf_wire_type::fixed32;
+        /// @endcond
+
+        /// value
+        float value = 0.0f;
+
+        /// Construct float_value_type with value 0.0
+        constexpr float_value_type() noexcept = default;
+
+        /// Construct float_value_type
+        explicit constexpr float_value_type(float v) :
+            value(v) {
+        }
+
+    }; // struct float_value_type
+
+    /// property value type holding a double
+    struct double_value_type {
+
+        /// the underlying storage type
+        using type = double;
+
+        /// @cond internal
+        constexpr static const property_value_type pvtype = property_value_type::double_value;
+        constexpr static const protozero::pbf_wire_type wire_type = protozero::pbf_wire_type::fixed64;
+        /// @endcond
+
+        /// value
+        double value = 0.0;
+
+        /// Construct double_value_type with value 0.0
+        constexpr double_value_type() noexcept = default;
+
+        /// Construct double_value_type
+        explicit constexpr double_value_type(double v) :
+            value(v) {
+        }
+
+    }; // struct double_value_type
+
+    /// property value type holding an int
+    struct int_value_type {
+
+        /// the underlying storage type
+        using type = int64_t;
+
+        /// @cond internal
+        constexpr static const property_value_type pvtype = property_value_type::int_value;
+        constexpr static const protozero::pbf_wire_type wire_type = protozero::pbf_wire_type::varint;
+        /// @endcond
+
+        /// value
+        int64_t value = 0;
+
+        /// Construct int_value_type with value 0
+        constexpr int_value_type() noexcept = default;
+
+        /// Construct int_value_type
+        explicit constexpr int_value_type(int64_t v) :
+            value(v) {
+        }
+
+    }; // struct int_value_type
+
+    /// property value type holding a uint
+    struct uint_value_type {
+
+        /// the underlying storage type
+        using type = uint64_t;
+
+        /// @cond internal
+        constexpr static const property_value_type pvtype = property_value_type::uint_value;
+        constexpr static const protozero::pbf_wire_type wire_type = protozero::pbf_wire_type::varint;
+        /// @endcond
+
+        /// value
+        uint64_t value = 0;
+
+        /// Construct uint_value_type with value 0
+        constexpr uint_value_type() noexcept = default;
+
+        /// Construct uint_value_type
+        explicit constexpr uint_value_type(uint64_t v) :
+            value(v) {
+        }
+
+    }; // struct uint_value_type
+
+    /// property value type holding an sint
+    struct sint_value_type {
+
+        /// the underlying storage type
+        using type = int64_t;
+
+        /// @cond internal
+        constexpr static const property_value_type pvtype = property_value_type::sint_value;
+        constexpr static const protozero::pbf_wire_type wire_type = protozero::pbf_wire_type::varint;
+        /// @endcond
+
+        /// value
+        int64_t value = 0;
+
+        /// Construct sint_value_type with value 0
+        constexpr sint_value_type() noexcept = default;
+
+        /// Construct sint_value_type
+        explicit constexpr sint_value_type(int64_t v) :
+            value(v) {
+        }
+
+    }; // struct sint_value_type
+
+    /// property value type holding a bool
+    struct bool_value_type {
+
+        /// the underlying storage type
+        using type = bool;
+
+        /// @cond internal
+        constexpr static const property_value_type pvtype = property_value_type::bool_value;
+        constexpr static const protozero::pbf_wire_type wire_type = protozero::pbf_wire_type::varint;
+        /// @endcond
+
+        /// value
+        bool value = false;
+
+        /// Construct bool_value_type with false value
+        constexpr bool_value_type() noexcept = default;
+
+        /// Construct bool_value_type
+        explicit constexpr bool_value_type(bool v) :
+            value(v) {
+        }
+
+    }; // struct bool_value_type
+
+    /**
+     * This class wraps the uint32_t used for looking up keys/values in the
+     * key/values tables.
+     */
+    class index_value {
+
+        static const uint32_t invalid_value = std::numeric_limits<uint32_t>::max();
+
+        uint32_t m_value = invalid_value;
+
+    public:
+
+        /// Default construct to an invalid value.
+        constexpr index_value() noexcept = default;
+
+        /// Construct with the given value.
+        constexpr index_value(uint32_t value) noexcept : // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
+            m_value(value) {
+        }
+
+        /**
+         * Is this index value valid? Index values are valid if they have
+         * been initialized with something other than the default constructor.
+         */
+        constexpr bool valid() const noexcept {
+            return m_value != invalid_value;
+        }
+
+        /**
+         * Get the value.
+         *
+         * @pre Must be valid.
+         */
+        uint32_t value() const noexcept {
+            vtzero_assert_in_noexcept_function(valid());
+            return m_value;
+        }
+
+    }; // class index_value
+
+    /// Index values are equal if their values are.
+    inline bool operator==(const index_value lhs, const index_value rhs) noexcept {
+        return lhs.value() == rhs.value();
+    }
+
+    /// Index values are not equal if their values are not equal.
+    inline bool operator!=(const index_value lhs, const index_value rhs) noexcept {
+        return lhs.value() != rhs.value();
+    }
+
+    /**
+     * This class holds two index_values, one for a key and one for a value.
+     */
+    class index_value_pair {
+
+        index_value m_key{};
+        index_value m_value{};
+
+    public:
+
+        /// Default construct to an invalid value.
+        constexpr index_value_pair() noexcept = default;
+
+        /// Construct with the given values.
+        constexpr index_value_pair(index_value key, index_value value) noexcept :
+            m_key(key),
+            m_value(value) {
+        }
+
+        /**
+         * Is this index value pair valid? Index values pairs are valid if
+         * both the key and the value index value are valid.
+         */
+        constexpr bool valid() const noexcept {
+            return m_key.valid() && m_value.valid();
+        }
+
+        /**
+         * Is this index value pair valid? Index values pairs are valid if
+         * both the key and the value index value are valid.
+         */
+        constexpr explicit operator bool() const noexcept {
+            return valid();
+        }
+
+        /// Get the key index value.
+        constexpr index_value key() const noexcept {
+            return m_key;
+        }
+
+        /// Get the value index value.
+        constexpr index_value value() const noexcept {
+            return m_value;
+        }
+
+    }; // class index_value_pair
+
+    /**
+     * The geometry class holds a geometry type and a reference to the data
+     * defining this geometry. To actually decode these geometries, use the
+     * decode_point_geometry(), decode_linestring_geometry(), and
+     * decode_polygon_geometry() classes.
+     */
+    class geometry {
+
+        data_view m_data{};
+        GeomType m_type = GeomType::UNKNOWN;
+
+    public:
+
+        /**
+         * A forward iterator yielding 32bit unsigned integers with the
+         * geometry encoded according to spec 4.3.
+         */
+        using const_iterator = protozero::pbf_reader::const_uint32_iterator;
+
+        /// Default construct to an invalid value.
+        constexpr geometry() noexcept = default;
+
+        /// Construct with the given values.
+        constexpr geometry(data_view data, GeomType type) noexcept :
+            m_data(data),
+            m_type(type) {
+        }
+
+        /// The data of this geometry
+        constexpr data_view data() const noexcept {
+            return m_data;
+        }
+
+        /// The type of this geometry
+        constexpr GeomType type() const noexcept {
+            return m_type;
+        }
+
+        /// Return iterator to the beginning of the data.
+        const_iterator begin() const noexcept {
+            return {m_data.data(), m_data.data() + m_data.size()};
+        }
+
+        /// Return iterator to one past the end of the data.
+        const_iterator end() const noexcept {
+            return {m_data.data() + m_data.size(), m_data.data() + m_data.size()};
+        }
+
+    }; // class geometry
+
+} // namespace vtzero
+
+#endif // VTZERO_TYPES_HPP
diff --git a/third_party/vtzero/include/vtzero/vector_tile.hpp b/third_party/vtzero/include/vtzero/vector_tile.hpp
new file mode 100644
index 00000000000..99352926ee2
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/vector_tile.hpp
@@ -0,0 +1,290 @@
+#ifndef VTZERO_VECTOR_TILE_HPP
+#define VTZERO_VECTOR_TILE_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file vector_tile.hpp
+ *
+ * @brief Contains the vector_tile class.
+ */
+
+#include "exception.hpp"
+#include "layer.hpp"
+#include "types.hpp"
+
+#include <protozero/pbf_message.hpp>
+
+#include <cstddef>
+#include <cstring>
+#include <iterator>
+#include <string>
+
+namespace vtzero {
+
+    /**
+     * A vector tile is basically nothing more than an ordered collection
+     * of named layers. For the most efficient way to access the layers,
+     * call next_layer() until it returns an invalid layer:
+     *
+     * @code
+     *   std::string data = ...;
+     *   vector_tile tile{data};
+     *   while (auto layer = tile.next_layer()) {
+     *     ...
+     *   }
+     * @endcode
+     *
+     * If you know the index of the layer, you can get it directly with
+     * @code
+     *   tile.get_layer(4);
+     * @endcode
+     *
+     * You can also access the layer by name:
+     * @code
+     *   tile.get_layer_by_name("foobar");
+     * @endcode
+     */
+    class vector_tile {
+
+        data_view m_data;
+        protozero::pbf_message<detail::pbf_tile> m_tile_reader;
+
+    public:
+
+        /**
+         * Construct the vector_tile from a data_view. The vector_tile object
+         * will keep a reference to the data referenced by the data_view. No
+         * copy of the data is created.
+         */
+        explicit vector_tile(const data_view data) noexcept :
+            m_data(data),
+            m_tile_reader(m_data) {
+        }
+
+        /**
+         * Construct the vector_tile from a string. The vector_tile object
+         * will keep a reference to the data referenced by the string. No
+         * copy of the data is created.
+         */
+        explicit vector_tile(const std::string& data) noexcept :
+            m_data(data.data(), data.size()),
+            m_tile_reader(m_data) {
+        }
+
+        /**
+         * Construct the vector_tile from a ptr and size. The vector_tile
+         * object will keep a reference to the data. No copy of the data is
+         * created.
+         */
+        vector_tile(const char* data, std::size_t size) noexcept :
+            m_data(data, size),
+            m_tile_reader(m_data) {
+        }
+
+        /**
+         * Is this vector tile empty?
+         *
+         * @returns true if there are no layers in this vector tile, false
+         *          otherwise
+         * Complexity: Constant.
+         */
+        bool empty() const noexcept {
+            return m_data.empty();
+        }
+
+        /**
+         * Return the number of layers in this tile.
+         *
+         * Complexity: Linear in the number of layers.
+         *
+         * @returns the number of layers in this tile
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         */
+        std::size_t count_layers() const {
+            std::size_t size = 0;
+
+            protozero::pbf_message<detail::pbf_tile> tile_reader{m_data};
+            while (tile_reader.next(detail::pbf_tile::layers,
+                                    protozero::pbf_wire_type::length_delimited)) {
+                tile_reader.skip();
+                ++size;
+            }
+
+            return size;
+        }
+
+        /**
+         * Get the next layer in this tile.
+         *
+         * Complexity: Constant.
+         *
+         * @returns layer The next layer or the invalid layer if there are no
+         *                more layers.
+         * @throws format_exception if the tile data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         */
+        layer next_layer() {
+            const bool has_next = m_tile_reader.next(detail::pbf_tile::layers,
+                                                     protozero::pbf_wire_type::length_delimited);
+
+            return has_next ? layer{m_tile_reader.get_view()} : layer{};
+        }
+
+        /**
+         * Reset the layer iterator. The next time next_layer() is called,
+         * it will begin from the first layer again.
+         *
+         * Complexity: Constant.
+         */
+        void reset_layer() noexcept {
+            m_tile_reader = protozero::pbf_message<detail::pbf_tile>{m_data};
+        }
+
+        /**
+         * Call a function for each layer in this tile.
+         *
+         * @tparam The type of the function. It must take a single argument
+         *         of type layer&& and return a bool. If the function returns
+         *         false, the iteration will be stopped.
+         * @param func The function to call.
+         * @returns true if the iteration was completed and false otherwise.
+         */
+        template <typename TFunc>
+        bool for_each_layer(TFunc&& func) const {
+            protozero::pbf_message<detail::pbf_tile> tile_reader{m_data};
+
+            while (tile_reader.next(detail::pbf_tile::layers,
+                                    protozero::pbf_wire_type::length_delimited)) {
+                if (!std::forward<TFunc>(func)(layer{tile_reader.get_view()})) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /**
+         * Returns the layer with the specified zero-based index.
+         *
+         * Complexity: Linear in the number of layers.
+         *
+         * @returns The specified layer or the invalid layer if index is
+         *          larger than the number of layers.
+         * @throws format_exception if the tile data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         */
+        layer get_layer(std::size_t index) const {
+            protozero::pbf_message<detail::pbf_tile> tile_reader{m_data};
+
+            while (tile_reader.next(detail::pbf_tile::layers,
+                                    protozero::pbf_wire_type::length_delimited)) {
+                if (index == 0) {
+                    return layer{tile_reader.get_view()};
+                }
+                tile_reader.skip();
+                --index;
+            }
+
+            return layer{};
+        }
+
+        /**
+         * Returns the layer with the specified name.
+         *
+         * Complexity: Linear in the number of layers.
+         *
+         * If there are several layers with the same name (which is against
+         * the spec 4.1 "A Vector Tile MUST NOT contain two or more layers
+         * whose name values are byte-for-byte identical.") it is unspecified
+         * which will be returned.
+         *
+         * @returns The specified layer or the invalid layer if there is no
+         *          layer with this name.
+         * @throws format_exception if the tile data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         */
+        layer get_layer_by_name(const data_view name) const {
+            protozero::pbf_message<detail::pbf_tile> tile_reader{m_data};
+
+            while (tile_reader.next(detail::pbf_tile::layers,
+                                    protozero::pbf_wire_type::length_delimited)) {
+                const auto layer_data = tile_reader.get_view();
+                protozero::pbf_message<detail::pbf_layer> layer_reader{layer_data};
+                if (layer_reader.next(detail::pbf_layer::name,
+                                      protozero::pbf_wire_type::length_delimited)) {
+                    if (layer_reader.get_view() == name) {
+                        return layer{layer_data};
+                    }
+                } else {
+                    // 4.1 "A layer MUST contain a name field."
+                    throw format_exception{"missing name in layer (spec 4.1)"};
+                }
+            }
+
+            return layer{};
+        }
+
+        /**
+         * Returns the layer with the specified name.
+         *
+         * Complexity: Linear in the number of layers.
+         *
+         * If there are several layers with the same name (which is against
+         * the spec 4.1 "A Vector Tile MUST NOT contain two or more layers
+         * whose name values are byte-for-byte identical.") it is unspecified
+         * which will be returned.
+         *
+         * @returns The specified layer or the invalid layer if there is no
+         *          layer with this name.
+         * @throws format_exception if the tile data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         */
+        layer get_layer_by_name(const std::string& name) const {
+            return get_layer_by_name(data_view{name.data(), name.size()});
+        }
+
+        /**
+         * Returns the layer with the specified name.
+         *
+         * Complexity: Linear in the number of layers.
+         *
+         * If there are several layers with the same name (which is against
+         * the spec 4.1 "A Vector Tile MUST NOT contain two or more layers
+         * whose name values are byte-for-byte identical.") it is unspecified
+         * which will be returned.
+         *
+         * @returns The specified layer or the invalid layer if there is no
+         *          layer with this name.
+         * @throws format_exception if the tile data is ill-formed.
+         * @throws any protozero exception if the protobuf encoding is invalid.
+         */
+        layer get_layer_by_name(const char* name) const {
+            return get_layer_by_name(data_view{name, std::strlen(name)});
+        }
+
+    }; // class vector_tile
+
+    /**
+     * Helper function to determine whether some data could represent a
+     * vector tile. This takes advantage of the fact that the first byte of
+     * a vector tile is always 0x1a. It can't be 100% reliable though, because
+     * some other data could still contain that byte.
+     *
+     * @returns false if this is definitely no vector tile
+     *          true if this could be a vector tile
+     */
+    inline bool is_vector_tile(const data_view data) noexcept {
+        return !data.empty() && data.data()[0] == 0x1a;
+    }
+
+} // namespace vtzero
+
+#endif // VTZERO_VECTOR_TILE_HPP
diff --git a/third_party/vtzero/include/vtzero/version.hpp b/third_party/vtzero/include/vtzero/version.hpp
new file mode 100644
index 00000000000..2cf9df887c2
--- /dev/null
+++ b/third_party/vtzero/include/vtzero/version.hpp
@@ -0,0 +1,36 @@
+#ifndef VTZERO_VERSION_HPP
+#define VTZERO_VERSION_HPP
+
+/*****************************************************************************
+
+vtzero - Tiny and fast vector tile decoder and encoder in C++.
+
+This file is from https://github.com/mapbox/vtzero where you can find more
+documentation.
+
+*****************************************************************************/
+
+/**
+ * @file version.hpp
+ *
+ * @brief Contains the version number macros for the vtzero library.
+ */
+
+/// The major version number
+#define VTZERO_VERSION_MAJOR 1
+
+/// The minor version number
+#define VTZERO_VERSION_MINOR 0
+
+/// The patch number
+#define VTZERO_VERSION_PATCH 1
+
+/// The complete version number
+#define VTZERO_VERSION_CODE                                      \
+    (VTZERO_VERSION_MAJOR * 10000 + VTZERO_VERSION_MINOR * 100 + \
+     VTZERO_VERSION_PATCH)
+
+/// Version number as string
+#define VTZERO_VERSION_STRING "1.0.1"
+
+#endif // VTZERO_VERSION_HPP
diff --git a/third_party/vtzero/test/CMakeLists.txt b/third_party/vtzero/test/CMakeLists.txt
new file mode 100644
index 00000000000..4beecc14ee5
--- /dev/null
+++ b/third_party/vtzero/test/CMakeLists.txt
@@ -0,0 +1,81 @@
+#-----------------------------------------------------------------------------
+#
+#  CMake config
+#
+#  vtzero tests
+#
+#-----------------------------------------------------------------------------
+
+if(Boost_FOUND)
+    message(STATUS "Boost library found: enable testing with boost::variant")
+    add_definitions(-DVTZERO_TEST_WITH_VARIANT)
+    include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
+else()
+    message(STATUS "Boost library not found: disable testing with boost::variant")
+endif()
+
+include_directories(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/catch")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include")
+
+set(TEST_SOURCES builder
+                 builder_linestring
+                 builder_point
+                 builder_polygon
+                 exceptions
+                 feature
+                 geometry
+                 geometry_linestring
+                 geometry_point
+                 geometry_polygon
+                 index
+                 layer
+                 output
+                 point
+                 property_map
+                 property_value
+                 types
+                 vector_tile)
+
+string(REGEX REPLACE "([^;]+)" "t/test_\\1.cpp" _test_sources "${TEST_SOURCES}")
+
+add_executable(unit-tests test_main.cpp ${_test_sources})
+
+add_executable(fixture-tests test_main.cpp fixture_tests.cpp)
+
+add_test(NAME unit-tests
+         COMMAND unit-tests
+         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(_fixtures ${MVT_FIXTURES}/fixtures)
+if(EXISTS ${_fixtures})
+    message(STATUS "Found test fixtures. Enabled mvt fixture tests.")
+    add_test(NAME fixture-tests
+             COMMAND fixture-tests)
+
+    set_tests_properties(fixture-tests PROPERTIES
+                         ENVIRONMENT "FIXTURES_DIR=${_fixtures}")
+
+    if(NOT WIN32)
+        set(_real_world_dir ${MVT_FIXTURES}/real-world)
+        file(GLOB real_world ${_real_world_dir}/bangkok/*
+                             ${_real_world_dir}/chicago/*
+                             ${_real_world_dir}/nepal/*
+                             ${_real_world_dir}/norway/*
+                             ${_real_world_dir}/sanfrancisco/*
+                             ${_real_world_dir}/uruguay/*)
+
+        if(NOT "${real_world}" STREQUAL "")
+            execute_process(COMMAND cat ${real_world}
+                            OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/real-world-all.mvt)
+
+            add_test(NAME vtzero-show-real-world
+                    COMMAND vtzero-show ${CMAKE_BINARY_DIR}/test/real-world-all.mvt)
+        endif()
+    endif()
+else()
+    message(WARNING "Disabled mvt fixture tests, because fixtures not found.\n  Install them by calling 'git submodule update --init' in ${CMAKE_SOURCE_DIR}.")
+endif()
+
+
+
+#-----------------------------------------------------------------------------
diff --git a/third_party/vtzero/test/catch/catch.hpp b/third_party/vtzero/test/catch/catch.hpp
new file mode 100644
index 00000000000..6b5129d60f9
--- /dev/null
+++ b/third_party/vtzero/test/catch/catch.hpp
@@ -0,0 +1,11678 @@
+/*
+ *  Catch v1.12.0
+ *  Generated: 2018-01-11 21:56:34.893972
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
+#define TWOBLUECUBES_CATCH_HPP_INCLUDED
+
+#ifdef __clang__
+#    pragma clang system_header
+#elif defined __GNUC__
+#    pragma GCC system_header
+#endif
+
+// #included from: internal/catch_suppress_warnings.h
+
+#ifdef __clang__
+#   ifdef __ICC // icpc defines the __clang__ macro
+#       pragma warning(push)
+#       pragma warning(disable: 161 1682)
+#   else // __ICC
+#       pragma clang diagnostic ignored "-Wglobal-constructors"
+#       pragma clang diagnostic ignored "-Wvariadic-macros"
+#       pragma clang diagnostic ignored "-Wc99-extensions"
+#       pragma clang diagnostic ignored "-Wunused-variable"
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wpadded"
+#       pragma clang diagnostic ignored "-Wc++98-compat"
+#       pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#       pragma clang diagnostic ignored "-Wswitch-enum"
+#       pragma clang diagnostic ignored "-Wcovered-switch-default"
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic ignored "-Wvariadic-macros"
+#    pragma GCC diagnostic ignored "-Wunused-variable"
+#    pragma GCC diagnostic ignored "-Wparentheses"
+
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wpadded"
+#endif
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
+#endif
+
+#ifdef CATCH_IMPL
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// #included from: internal/catch_notimplemented_exception.h
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
+
+// #included from: catch_common.h
+#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
+
+// #included from: catch_compiler_capabilities.h
+#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported?
+// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
+// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
+// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported?
+// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported
+// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported?
+// CATCH_CONFIG_CPP11_OVERRIDE : is override supported?
+// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
+// CATCH_CONFIG_CPP11_SHUFFLE : is std::shuffle supported?
+// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if supported?
+
+// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
+
+// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?
+// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11
+
+#ifdef __cplusplus
+
+#  if __cplusplus >= 201103L
+#    define CATCH_CPP11_OR_GREATER
+#  endif
+
+#  if __cplusplus >= 201402L
+#    define CATCH_CPP14_OR_GREATER
+#  endif
+
+#endif
+
+#ifdef __clang__
+
+#  if __has_feature(cxx_nullptr)
+#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#  endif
+
+#  if __has_feature(cxx_noexcept)
+#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#  endif
+
+#   if defined(CATCH_CPP11_OR_GREATER)
+#       define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
+
+#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
+#   endif
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined(__CYGWIN__) || defined(__QNX__)
+
+#   if !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#   endif
+
+#endif
+
+#ifdef __OS400__
+#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#       define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+#   define _BSD_SOURCE
+
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Borland
+#ifdef __BORLANDC__
+
+#endif // __BORLANDC__
+
+////////////////////////////////////////////////////////////////////////////////
+// EDG
+#ifdef __EDG_VERSION__
+
+#endif // __EDG_VERSION__
+
+////////////////////////////////////////////////////////////////////////////////
+// Digital Mars
+#ifdef __DMC__
+
+#endif // __DMC__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#   if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#       define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#   endif
+
+// - otherwise more recent versions define __cplusplus >= 201103L
+// and will get picked up below
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+
+#if (_MSC_VER >= 1600)
+#   define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#   define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
+#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
+#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
+#endif
+
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use variadic macros if the compiler supports them
+#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
+    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
+    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
+
+#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+
+#endif
+
+// Use __COUNTER__ if the compiler supports it
+#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \
+    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
+    ( defined __clang__ && __clang_major__ >= 3 )
+
+// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former,
+// because __COUNTER__ is not properly handled by it.
+// This does not affect compilation
+#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L )
+    #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// C++ language feature support
+
+// catch all support for C++11
+#if defined(CATCH_CPP11_OR_GREATER)
+
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR)
+#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#    define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
+#    define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE
+#    define CATCH_INTERNAL_CONFIG_CPP11_TUPLE
+#  endif
+
+#  ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+#    define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+#  endif
+
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG)
+#    define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG
+#  endif
+
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE)
+#    define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE
+#  endif
+#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
+#    define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#  endif
+# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE)
+#   define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
+#  endif
+# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS)
+#  define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
+# endif
+
+#endif // __cplusplus >= 201103L
+
+// Now set the actual defines based on the above + anything the user has configured
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_NULLPTR
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_NOEXCEPT
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_GENERATED_METHODS
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_IS_ENUM
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_TUPLE
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS)
+#   define CATCH_CONFIG_VARIADIC_MACROS
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_LONG_LONG
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_OVERRIDE
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_UNIQUE_PTR
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
+#   define CATCH_CONFIG_COUNTER
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)
+#   define CATCH_CONFIG_CPP11_SHUFFLE
+#endif
+# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11)
+#  define CATCH_CONFIG_CPP11_TYPE_TRAITS
+# endif
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)
+#   define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#   define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+#endif
+
+// noexcept support:
+#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
+#  define CATCH_NOEXCEPT noexcept
+#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
+#else
+#  define CATCH_NOEXCEPT throw()
+#  define CATCH_NOEXCEPT_IS(x)
+#endif
+
+// nullptr support
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+#   define CATCH_NULL nullptr
+#else
+#   define CATCH_NULL NULL
+#endif
+
+// override support
+#ifdef CATCH_CONFIG_CPP11_OVERRIDE
+#   define CATCH_OVERRIDE override
+#else
+#   define CATCH_OVERRIDE
+#endif
+
+// unique_ptr support
+#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR
+#   define CATCH_AUTO_PTR( T ) std::unique_ptr<T>
+#else
+#   define CATCH_AUTO_PTR( T ) std::auto_ptr<T>
+#endif
+
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
+#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
+
+#include <sstream>
+#include <algorithm>
+
+namespace Catch {
+
+    struct IConfig;
+
+    struct CaseSensitive { enum Choice {
+        Yes,
+        No
+    }; };
+
+    class NonCopyable {
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+#else
+        NonCopyable( NonCopyable const& info );
+        NonCopyable& operator = ( NonCopyable const& );
+#endif
+
+    protected:
+        NonCopyable() {}
+        virtual ~NonCopyable();
+    };
+
+    class SafeBool {
+    public:
+        typedef void (SafeBool::*type)() const;
+
+        static type makeSafe( bool value ) {
+            return value ? &SafeBool::trueValue : 0;
+        }
+    private:
+        void trueValue() const {}
+    };
+
+    template<typename ContainerT>
+    void deleteAll( ContainerT& container ) {
+        typename ContainerT::const_iterator it = container.begin();
+        typename ContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete *it;
+    }
+    template<typename AssociativeContainerT>
+    void deleteAllValues( AssociativeContainerT& container ) {
+        typename AssociativeContainerT::const_iterator it = container.begin();
+        typename AssociativeContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete it->second;
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( std::string const& s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    std::string trim( std::string const& str );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo();
+        SourceLineInfo( char const* _file, std::size_t _line );
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        SourceLineInfo(SourceLineInfo const& other)          = default;
+        SourceLineInfo( SourceLineInfo && )                  = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
+        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
+#  endif
+        bool empty() const;
+        bool operator == ( SourceLineInfo const& other ) const;
+        bool operator < ( SourceLineInfo const& other ) const;
+
+        char const* file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // This is just here to avoid compiler warnings with macro constants and boolean literals
+    inline bool isTrue( bool value ){ return value; }
+    inline bool alwaysTrue() { return true; }
+    inline bool alwaysFalse() { return false; }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );
+
+    void seedRng( IConfig const& config );
+    unsigned int rngSeed();
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() {
+            return std::string();
+        }
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );
+
+namespace Catch {
+
+    class NotImplementedException : public std::exception
+    {
+    public:
+        NotImplementedException( SourceLineInfo const& lineInfo );
+
+        virtual ~NotImplementedException() CATCH_NOEXCEPT {}
+
+        virtual const char* what() const CATCH_NOEXCEPT;
+
+    private:
+        std::string m_what;
+        SourceLineInfo m_lineInfo;
+    };
+
+} // end namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
+
+// #included from: internal/catch_context.h
+#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
+
+// #included from: catch_interfaces_generators.h
+#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct IGeneratorInfo {
+        virtual ~IGeneratorInfo();
+        virtual bool moveNext() = 0;
+        virtual std::size_t getCurrentIndex() const = 0;
+    };
+
+    struct IGeneratorsForTest {
+        virtual ~IGeneratorsForTest();
+
+        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
+        virtual bool moveNext() = 0;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest();
+
+} // end namespace Catch
+
+// #included from: catch_ptr.hpp
+#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    // An intrusive reference counting smart pointer.
+    // T must implement addRef() and release() methods
+    // typically implementing the IShared interface
+    template<typename T>
+    class Ptr {
+    public:
+        Ptr() : m_p( CATCH_NULL ){}
+        Ptr( T* p ) : m_p( p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        Ptr( Ptr const& other ) : m_p( other.m_p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        ~Ptr(){
+            if( m_p )
+                m_p->release();
+        }
+        void reset() {
+            if( m_p )
+                m_p->release();
+            m_p = CATCH_NULL;
+        }
+        Ptr& operator = ( T* p ){
+            Ptr temp( p );
+            swap( temp );
+            return *this;
+        }
+        Ptr& operator = ( Ptr const& other ){
+            Ptr temp( other );
+            swap( temp );
+            return *this;
+        }
+        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
+        T* get() const{ return m_p; }
+        T& operator*() const { return *m_p; }
+        T* operator->() const { return m_p; }
+        bool operator !() const { return m_p == CATCH_NULL; }
+        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); }
+
+    private:
+        T* m_p;
+    };
+
+    struct IShared : NonCopyable {
+        virtual ~IShared();
+        virtual void addRef() const = 0;
+        virtual void release() const = 0;
+    };
+
+    template<typename T = IShared>
+    struct SharedImpl : T {
+
+        SharedImpl() : m_rc( 0 ){}
+
+        virtual void addRef() const {
+            ++m_rc;
+        }
+        virtual void release() const {
+            if( --m_rc == 0 )
+                delete this;
+        }
+
+        mutable unsigned int m_rc;
+    };
+
+} // end namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace Catch {
+
+    class TestCase;
+    class Stream;
+    struct IResultCapture;
+    struct IRunner;
+    struct IGeneratorsForTest;
+    struct IConfig;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
+        virtual bool advanceGeneratorsForCurrentTest() = 0;
+        virtual Ptr<IConfig const> getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
+    };
+
+    IContext& getCurrentContext();
+    IMutableContext& getCurrentMutableContext();
+    void cleanUpContext();
+    Stream createStream( std::string const& streamName );
+
+}
+
+// #included from: internal/catch_test_registry.hpp
+#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_interfaces_testcase.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestCase : IShared {
+        virtual void invoke () const = 0;
+    protected:
+        virtual ~ITestCase();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
+    };
+
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+}
+
+namespace Catch {
+
+template<typename C>
+class MethodTestCase : public SharedImpl<ITestCase> {
+
+public:
+    MethodTestCase( void (C::*method)() ) : m_method( method ) {}
+
+    virtual void invoke() const {
+        C obj;
+        (obj.*m_method)();
+    }
+
+private:
+    virtual ~MethodTestCase() {}
+
+    void (C::*m_method)();
+};
+
+typedef void(*TestFunction)();
+
+struct NameAndDesc {
+    NameAndDesc( const char* _name = "", const char* _description= "" )
+    : name( _name ), description( _description )
+    {}
+
+    const char* name;
+    const char* description;
+};
+
+void registerTestCase
+    (   ITestCase* testCase,
+        char const* className,
+        NameAndDesc const& nameAndDesc,
+        SourceLineInfo const& lineInfo );
+
+struct AutoReg {
+
+    AutoReg
+        (   TestFunction function,
+            SourceLineInfo const& lineInfo,
+            NameAndDesc const& nameAndDesc );
+
+    template<typename C>
+    AutoReg
+        (   void (C::*method)(),
+            char const* className,
+            NameAndDesc const& nameAndDesc,
+            SourceLineInfo const& lineInfo ) {
+
+        registerTestCase
+            (   new MethodTestCase<C>( method ),
+                className,
+                nameAndDesc,
+                lineInfo );
+    }
+
+    ~AutoReg();
+
+private:
+    AutoReg( AutoReg const& );
+    void operator= ( AutoReg const& );
+};
+
+void registerTestCaseFunction
+    (   TestFunction function,
+        SourceLineInfo const& lineInfo,
+        NameAndDesc const& nameAndDesc );
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+        static void TestName(); \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ \
+            struct TestName : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+#else
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \
+        static void TestName(); \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        namespace{ \
+            struct TestCaseName : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
+        } \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        void TestCaseName::test()
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \
+        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); /* NOLINT */ \
+        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+#endif
+
+// #included from: internal/catch_capture.hpp
+#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
+
+// #included from: catch_result_builder.h
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
+
+// #included from: catch_result_type.h
+#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
+
+    }; };
+
+    inline bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    inline bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x01,
+
+        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
+        FalseTest = 0x04,           // Prefix expression with !
+        SuppressFail = 0x08         // Failures are reported but do not fail the test
+    }; };
+
+    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.h
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
+
+    struct DecomposedExpression
+    {
+        virtual ~DecomposedExpression() {}
+        virtual bool isBinaryExpression() const {
+            return false;
+        }
+        virtual void reconstructExpression( std::string& dest ) const = 0;
+
+        // Only simple binary comparisons can be decomposed.
+        // If more complex check is required then wrap sub-expressions in parentheses.
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator % ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
+        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );
+
+    private:
+        DecomposedExpression& operator = (DecomposedExpression const&);
+    };
+
+    struct AssertionInfo
+    {
+        AssertionInfo();
+        AssertionInfo(  char const * _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        char const * _capturedExpression,
+                        ResultDisposition::Flags _resultDisposition,
+                        char const * _secondArg = "");
+
+        char const * macroName;
+        SourceLineInfo lineInfo;
+        char const * capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+        char const * secondArg;
+    };
+
+    struct AssertionResultData
+    {
+        AssertionResultData() : decomposedExpression( CATCH_NULL )
+                              , resultType( ResultWas::Unknown )
+                              , negated( false )
+                              , parenthesized( false ) {}
+
+        void negate( bool parenthesize ) {
+            negated = !negated;
+            parenthesized = parenthesize;
+            if( resultType == ResultWas::Ok )
+                resultType = ResultWas::ExpressionFailed;
+            else if( resultType == ResultWas::ExpressionFailed )
+                resultType = ResultWas::Ok;
+        }
+
+        std::string const& reconstructExpression() const {
+            if( decomposedExpression != CATCH_NULL ) {
+                decomposedExpression->reconstructExpression( reconstructedExpression );
+                if( parenthesized ) {
+                    reconstructedExpression.insert( 0, 1, '(' );
+                    reconstructedExpression.append( 1, ')' );
+                }
+                if( negated ) {
+                    reconstructedExpression.insert( 0, 1, '!' );
+                }
+                decomposedExpression = CATCH_NULL;
+            }
+            return reconstructedExpression;
+        }
+
+        mutable DecomposedExpression const* decomposedExpression;
+        mutable std::string reconstructedExpression;
+        std::string message;
+        ResultWas::OfType resultType;
+        bool negated;
+        bool parenthesized;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult();
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+        ~AssertionResult();
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+         AssertionResult( AssertionResult const& )              = default;
+         AssertionResult( AssertionResult && )                  = default;
+         AssertionResult& operator = ( AssertionResult const& ) = default;
+         AssertionResult& operator = ( AssertionResult && )     = default;
+#  endif
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        std::string getTestMacroName() const;
+        void discardDecomposedExpression() const;
+        void expandDecomposedExpression() const;
+
+    protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_matchers.hpp
+#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        template<typename ArgT> struct MatchAllOf;
+        template<typename ArgT> struct MatchAnyOf;
+        template<typename ArgT> struct MatchNotOf;
+
+        class MatcherUntypedBase {
+        public:
+            std::string toString() const {
+                if( m_cachedToString.empty() )
+                    m_cachedToString = describe();
+                return m_cachedToString;
+            }
+
+        protected:
+            virtual ~MatcherUntypedBase();
+            virtual std::string describe() const = 0;
+            mutable std::string m_cachedToString;
+        private:
+            MatcherUntypedBase& operator = ( MatcherUntypedBase const& );
+        };
+
+        template<typename ObjectT>
+        struct MatcherMethod {
+            virtual bool match( ObjectT const& arg ) const = 0;
+        };
+        template<typename PtrT>
+        struct MatcherMethod<PtrT*> {
+            virtual bool match( PtrT* arg ) const = 0;
+        };
+
+        template<typename ObjectT, typename ComparatorT = ObjectT>
+        struct MatcherBase : MatcherUntypedBase, MatcherMethod<ObjectT> {
+
+            MatchAllOf<ComparatorT> operator && ( MatcherBase const& other ) const;
+            MatchAnyOf<ComparatorT> operator || ( MatcherBase const& other ) const;
+            MatchNotOf<ComparatorT> operator ! () const;
+        };
+
+        template<typename ArgT>
+        struct MatchAllOf : MatcherBase<ArgT> {
+            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if (!m_matchers[i]->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        description += " and ";
+                    description += m_matchers[i]->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
+                m_matchers.push_back( &other );
+                return *this;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+        template<typename ArgT>
+        struct MatchAnyOf : MatcherBase<ArgT> {
+
+            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if (m_matchers[i]->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        description += " or ";
+                    description += m_matchers[i]->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
+                m_matchers.push_back( &other );
+                return *this;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+
+        template<typename ArgT>
+        struct MatchNotOf : MatcherBase<ArgT> {
+
+            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "not " + m_underlyingMatcher.toString();
+            }
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+        };
+
+        template<typename ObjectT, typename ComparatorT>
+        MatchAllOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator && ( MatcherBase const& other ) const {
+            return MatchAllOf<ComparatorT>() && *this && other;
+        }
+        template<typename ObjectT, typename ComparatorT>
+        MatchAnyOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator || ( MatcherBase const& other ) const {
+            return MatchAnyOf<ComparatorT>() || *this || other;
+        }
+        template<typename ObjectT, typename ComparatorT>
+        MatchNotOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator ! () const {
+            return MatchNotOf<ComparatorT>( *this );
+        }
+
+    } // namespace Impl
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    // - deprecated: prefer ||, && and !
+    template<typename T>
+    Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
+        return Impl::MatchNotOf<T>( underlyingMatcher );
+    }
+    template<typename T>
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+        return Impl::MatchAllOf<T>() && m1 && m2;
+    }
+    template<typename T>
+    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+        return Impl::MatchAllOf<T>() && m1 && m2 && m3;
+    }
+    template<typename T>
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
+        return Impl::MatchAnyOf<T>() || m1 || m2;
+    }
+    template<typename T>
+    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
+        return Impl::MatchAnyOf<T>() || m1 || m2 || m3;
+    }
+
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+namespace Catch {
+
+    struct TestFailureException{};
+
+    template<typename T> class ExpressionLhs;
+
+    struct CopyableStream {
+        CopyableStream() {}
+        CopyableStream( CopyableStream const& other ) {
+            oss << other.oss.str();
+        }
+        CopyableStream& operator=( CopyableStream const& other ) {
+            oss.str(std::string());
+            oss << other.oss.str();
+            return *this;
+        }
+        std::ostringstream oss;
+    };
+
+    class ResultBuilder : public DecomposedExpression {
+    public:
+        ResultBuilder(  char const* macroName,
+                        SourceLineInfo const& lineInfo,
+                        char const* capturedExpression,
+                        ResultDisposition::Flags resultDisposition,
+                        char const* secondArg = "" );
+        ~ResultBuilder();
+
+        template<typename T>
+        ExpressionLhs<T const&> operator <= ( T const& operand );
+        ExpressionLhs<bool> operator <= ( bool value );
+
+        template<typename T>
+        ResultBuilder& operator << ( T const& value ) {
+            stream().oss << value;
+            return *this;
+        }
+
+        ResultBuilder& setResultType( ResultWas::OfType result );
+        ResultBuilder& setResultType( bool result );
+
+        void endExpression( DecomposedExpression const& expr );
+
+        virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE;
+
+        AssertionResult build() const;
+        AssertionResult build( DecomposedExpression const& expr ) const;
+
+        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
+        void captureResult( ResultWas::OfType resultType );
+        void captureExpression();
+        void captureExpectedException( std::string const& expectedMessage );
+        void captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher );
+        void handleResult( AssertionResult const& result );
+        void react();
+        bool shouldDebugBreak() const;
+        bool allowThrows() const;
+
+        template<typename ArgT, typename MatcherT>
+        void captureMatch( ArgT const& arg, MatcherT const& matcher, char const* matcherString );
+
+        void setExceptionGuard();
+        void unsetExceptionGuard();
+
+    private:
+        AssertionInfo m_assertionInfo;
+        AssertionResultData m_data;
+
+        CopyableStream &stream()
+        {
+            if(!m_usedStream)
+            {
+                m_usedStream = true;
+                m_stream().oss.str("");
+            }
+            return m_stream();
+        }
+
+        static CopyableStream &m_stream()
+        {
+            static CopyableStream s;
+            return s;
+        }
+
+        bool m_shouldDebugBreak;
+        bool m_shouldThrow;
+        bool m_guardException;
+        bool m_usedStream;
+    };
+
+} // namespace Catch
+
+// Include after due to circular dependency:
+// #included from: catch_expression_lhs.hpp
+#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
+
+// #included from: catch_evaluate.hpp
+#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#endif
+
+#include <cstddef>
+
+namespace Catch {
+namespace Internal {
+
+    enum Operator {
+        IsEqualTo,
+        IsNotEqualTo,
+        IsLessThan,
+        IsGreaterThan,
+        IsLessThanOrEqualTo,
+        IsGreaterThanOrEqualTo
+    };
+
+    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
+    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
+    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
+    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
+    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
+    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
+    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
+
+    template<typename T>
+    T& opCast(T const& t) { return const_cast<T&>(t); }
+
+// nullptr_t support based on pull request #154 from Konstantin Baumann
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+    // So the compare overloads can be operator agnostic we convey the operator as a template
+    // enum, which is used to specialise an Evaluator for doing the comparison.
+    template<typename T1, typename T2, Operator Op>
+    struct Evaluator{};
+
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs) {
+            return bool( opCast( lhs ) ==  opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsNotEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) != opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) < opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) > opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) >= opCast( rhs ) );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return bool( opCast( lhs ) <= opCast( rhs ) );
+        }
+    };
+
+    template<Operator Op, typename T1, typename T2>
+    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // This level of indirection allows us to specialise for integer types
+    // to avoid signed/ unsigned warnings
+
+    // "base" overload
+    template<Operator Op, typename T1, typename T2>
+    bool compare( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // unsigned X to int
+    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+
+    // unsigned X to long
+    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+
+    // int to unsigned X
+    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+
+    // long to unsigned X
+    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // pointer to long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+    // pointer to int (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+    // long long to unsigned X
+    template<Operator Op> bool compare( long long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned long long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // unsigned long long to X
+    template<Operator Op> bool compare( unsigned long long lhs, int rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, long long rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( unsigned long long lhs, char rhs ) {
+        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
+    }
+
+    // pointer to long long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+#endif // CATCH_CONFIG_CPP11_LONG_LONG
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    // pointer to nullptr_t (when comparing against nullptr)
+    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
+    }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+} // end of namespace Internal
+} // end of namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// #included from: catch_tostring.h
+#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
+
+#include <sstream>
+#include <iomanip>
+#include <limits>
+#include <vector>
+#include <cstddef>
+
+#ifdef __OBJC__
+// #included from: catch_objc_arc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_TUPLE
+#include <tuple>
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_IS_ENUM
+#include <type_traits>
+#endif
+
+namespace Catch {
+
+// Why we're here.
+template<typename T>
+std::string toString( T const& value );
+
+// Built in overloads
+
+std::string toString( std::string const& value );
+std::string toString( std::wstring const& value );
+std::string toString( const char* const value );
+std::string toString( char* const value );
+std::string toString( const wchar_t* const value );
+std::string toString( wchar_t* const value );
+std::string toString( int value );
+std::string toString( unsigned long value );
+std::string toString( unsigned int value );
+std::string toString( const double value );
+std::string toString( const float value );
+std::string toString( bool value );
+std::string toString( char value );
+std::string toString( signed char value );
+std::string toString( unsigned char value );
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+std::string toString( long long value );
+std::string toString( unsigned long long value );
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t );
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring );
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring );
+    std::string toString( NSObject* const& nsObject );
+#endif
+
+namespace Detail {
+
+    extern const std::string unprintableString;
+
+ #if !defined(CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK)
+    struct BorgType {
+        template<typename T> BorgType( T const& );
+    };
+
+    struct TrueType { char sizer[1]; };
+    struct FalseType { char sizer[2]; };
+
+    TrueType& testStreamable( std::ostream& );
+    FalseType testStreamable( FalseType );
+
+    FalseType operator<<( std::ostream const&, BorgType const& );
+
+    template<typename T>
+    struct IsStreamInsertable {
+        static std::ostream &s;
+        static T  const&t;
+        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
+    };
+#else
+    template<typename T>
+    class IsStreamInsertable {
+        template<typename SS, typename TT>
+        static auto test(int)
+        -> decltype( std::declval<SS&>() << std::declval<TT>(), std::true_type() );
+
+        template<typename, typename>
+        static auto test(...) -> std::false_type;
+
+    public:
+        static const bool value = decltype(test<std::ostream,const T&>(0))::value;
+    };
+#endif
+
+#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
+    template<typename T,
+             bool IsEnum = std::is_enum<T>::value
+             >
+    struct EnumStringMaker
+    {
+        static std::string convert( T const& ) { return unprintableString; }
+    };
+
+    template<typename T>
+    struct EnumStringMaker<T,true>
+    {
+        static std::string convert( T const& v )
+        {
+            return ::Catch::toString(
+                static_cast<typename std::underlying_type<T>::type>(v)
+                );
+        }
+    };
+#endif
+    template<bool C>
+    struct StringMakerBase {
+#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
+        template<typename T>
+        static std::string convert( T const& v )
+        {
+            return EnumStringMaker<T>::convert( v );
+        }
+#else
+        template<typename T>
+        static std::string convert( T const& ) { return unprintableString; }
+#endif
+    };
+
+    template<>
+    struct StringMakerBase<true> {
+        template<typename T>
+        static std::string convert( T const& _value ) {
+            std::ostringstream oss;
+            oss << _value;
+            return oss.str();
+        }
+    };
+
+    std::string rawMemoryToString( const void *object, std::size_t size );
+
+    template<typename T>
+    std::string rawMemoryToString( const T& object ) {
+      return rawMemoryToString( &object, sizeof(object) );
+    }
+
+} // end namespace Detail
+
+template<typename T>
+struct StringMaker :
+    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
+
+template<typename T>
+struct StringMaker<T*> {
+    template<typename U>
+    static std::string convert( U* p ) {
+        if( !p )
+            return "NULL";
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+template<typename R, typename C>
+struct StringMaker<R C::*> {
+    static std::string convert( R C::* p ) {
+        if( !p )
+            return "NULL";
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last );
+}
+
+//template<typename T, typename Allocator>
+//struct StringMaker<std::vector<T, Allocator> > {
+//    static std::string convert( std::vector<T,Allocator> const& v ) {
+//        return Detail::rangeToString( v.begin(), v.end() );
+//    }
+//};
+
+template<typename T, typename Allocator>
+std::string toString( std::vector<T,Allocator> const& v ) {
+    return Detail::rangeToString( v.begin(), v.end() );
+}
+
+#ifdef CATCH_CONFIG_CPP11_TUPLE
+
+// toString for tuples
+namespace TupleDetail {
+  template<
+      typename Tuple,
+      std::size_t N = 0,
+      bool = (N < std::tuple_size<Tuple>::value)
+      >
+  struct ElementPrinter {
+      static void print( const Tuple& tuple, std::ostream& os )
+      {
+          os << ( N ? ", " : " " )
+             << Catch::toString(std::get<N>(tuple));
+          ElementPrinter<Tuple,N+1>::print(tuple,os);
+      }
+  };
+
+  template<
+      typename Tuple,
+      std::size_t N
+      >
+  struct ElementPrinter<Tuple,N,false> {
+      static void print( const Tuple&, std::ostream& ) {}
+  };
+
+}
+
+template<typename ...Types>
+struct StringMaker<std::tuple<Types...>> {
+
+    static std::string convert( const std::tuple<Types...>& tuple )
+    {
+        std::ostringstream os;
+        os << '{';
+        TupleDetail::ElementPrinter<std::tuple<Types...>>::print( tuple, os );
+        os << " }";
+        return os.str();
+    }
+};
+#endif // CATCH_CONFIG_CPP11_TUPLE
+
+namespace Detail {
+    template<typename T>
+    std::string makeString( T const& value ) {
+        return StringMaker<T>::convert( value );
+    }
+} // end namespace Detail
+
+/// \brief converts any type to a string
+///
+/// The default template forwards on to ostringstream - except when an
+/// ostringstream overload does not exist - in which case it attempts to detect
+/// that and writes {?}.
+/// Overload (not specialise) this template for custom typs that you don't want
+/// to provide an ostream overload for.
+template<typename T>
+std::string toString( T const& value ) {
+    return StringMaker<T>::convert( value );
+}
+
+    namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last ) {
+        std::ostringstream oss;
+        oss << "{ ";
+        if( first != last ) {
+            oss << Catch::toString( *first );
+            for( ++first ; first != last ; ++first )
+                oss << ", " << Catch::toString( *first );
+        }
+        oss << " }";
+        return oss.str();
+    }
+}
+
+} // end namespace Catch
+
+namespace Catch {
+
+template<typename LhsT, Internal::Operator Op, typename RhsT>
+class BinaryExpression;
+
+template<typename ArgT, typename MatcherT>
+class MatchExpression;
+
+// Wraps the LHS of an expression and overloads comparison operators
+// for also capturing those and RHS (if any)
+template<typename T>
+class ExpressionLhs : public DecomposedExpression {
+public:
+    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ), m_truthy(false) {}
+
+    ExpressionLhs& operator = ( const ExpressionLhs& );
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsEqualTo, RhsT const&>
+    operator == ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsNotEqualTo, RhsT const&>
+    operator != ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsLessThan, RhsT const&>
+    operator < ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThan>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsGreaterThan, RhsT const&>
+    operator > ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThan>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsLessThanOrEqualTo, RhsT const&>
+    operator <= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    BinaryExpression<T, Internal::IsGreaterThanOrEqualTo, RhsT const&>
+    operator >= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
+    }
+
+    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    void endExpression() {
+        m_truthy = m_lhs ? true : false;
+        m_rb
+            .setResultType( m_truthy )
+            .endExpression( *this );
+    }
+
+    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
+        dest = Catch::toString( m_lhs );
+    }
+
+private:
+    template<Internal::Operator Op, typename RhsT>
+    BinaryExpression<T, Op, RhsT&> captureExpression( RhsT& rhs ) const {
+        return BinaryExpression<T, Op, RhsT&>( m_rb, m_lhs, rhs );
+    }
+
+    template<Internal::Operator Op>
+    BinaryExpression<T, Op, bool> captureExpression( bool rhs ) const {
+        return BinaryExpression<T, Op, bool>( m_rb, m_lhs, rhs );
+    }
+
+private:
+    ResultBuilder& m_rb;
+    T m_lhs;
+    bool m_truthy;
+};
+
+template<typename LhsT, Internal::Operator Op, typename RhsT>
+class BinaryExpression : public DecomposedExpression {
+public:
+    BinaryExpression( ResultBuilder& rb, LhsT lhs, RhsT rhs )
+        : m_rb( rb ), m_lhs( lhs ), m_rhs( rhs ) {}
+
+    BinaryExpression& operator = ( BinaryExpression& );
+
+    void endExpression() const {
+        m_rb
+            .setResultType( Internal::compare<Op>( m_lhs, m_rhs ) )
+            .endExpression( *this );
+    }
+
+    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
+        return true;
+    }
+
+    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
+        std::string lhs = Catch::toString( m_lhs );
+        std::string rhs = Catch::toString( m_rhs );
+        char delim = lhs.size() + rhs.size() < 40 &&
+                     lhs.find('\n') == std::string::npos &&
+                     rhs.find('\n') == std::string::npos ? ' ' : '\n';
+        dest.reserve( 7 + lhs.size() + rhs.size() );
+                   // 2 for spaces around operator
+                   // 2 for operator
+                   // 2 for parentheses (conditionally added later)
+                   // 1 for negation (conditionally added later)
+        dest = lhs;
+        dest += delim;
+        dest += Internal::OperatorTraits<Op>::getName();
+        dest += delim;
+        dest += rhs;
+    }
+
+private:
+    ResultBuilder& m_rb;
+    LhsT m_lhs;
+    RhsT m_rhs;
+};
+
+template<typename ArgT, typename MatcherT>
+class MatchExpression : public DecomposedExpression {
+public:
+    MatchExpression( ArgT arg, MatcherT matcher, char const* matcherString )
+        : m_arg( arg ), m_matcher( matcher ), m_matcherString( matcherString ) {}
+
+    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
+        return true;
+    }
+
+    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
+        std::string matcherAsString = m_matcher.toString();
+        dest = Catch::toString( m_arg );
+        dest += ' ';
+        if( matcherAsString == Detail::unprintableString )
+            dest += m_matcherString;
+        else
+            dest += matcherAsString;
+    }
+
+private:
+    ArgT m_arg;
+    MatcherT m_matcher;
+    char const* m_matcherString;
+};
+
+} // end namespace Catch
+
+
+namespace Catch {
+
+    template<typename T>
+    ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
+        return ExpressionLhs<T const&>( *this, operand );
+    }
+
+    inline ExpressionLhs<bool> ResultBuilder::operator <= ( bool value ) {
+        return ExpressionLhs<bool>( *this, value );
+    }
+
+    template<typename ArgT, typename MatcherT>
+    void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
+                                             char const* matcherString ) {
+        MatchExpression<ArgT const&, MatcherT const&> expr( arg, matcher, matcherString );
+        setResultType( matcher.match( arg ) );
+        endExpression( expr );
+    }
+
+} // namespace Catch
+
+// #included from: catch_message.h
+#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        std::string macroName;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        std::string message;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const {
+            return sequence == other.sequence;
+        }
+        bool operator < ( MessageInfo const& other ) const {
+            return sequence < other.sequence;
+        }
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageBuilder {
+        MessageBuilder( std::string const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type )
+        : m_info( macroName, lineInfo, type )
+        {}
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+        std::ostringstream m_stream;
+    };
+
+    class ScopedMessage {
+    public:
+        ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage const& other );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_capture.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    class ScopedMessageBuilder;
+    struct Counts;
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual void assertionEnded( AssertionResult const& result ) = 0;
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+
+        virtual void exceptionEarlyReported() = 0;
+
+        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+        virtual void assertionRun() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// #included from: catch_debugger.h
+#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
+
+// #included from: catch_platform.h
+#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
+
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#  define CATCH_PLATFORM_MAC
+#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
+#  define CATCH_PLATFORM_IPHONE
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#  define CATCH_PLATFORM_WINDOWS
+#  if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
+#    define CATCH_DEFINES_NOMINMAX
+#  endif
+#  if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
+#    define CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#  endif
+#endif
+
+#include <string>
+
+namespace Catch{
+
+    bool isDebuggerActive();
+    void writeToDebugConsole( std::string const& text );
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    // The following code snippet based on:
+    // http://cocoawithlove.com/2008/03/break-into-debugger.html
+    #if defined(__ppc64__) || defined(__ppc__)
+        #define CATCH_TRAP() \
+                __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+                : : : "memory","r0","r3","r4" ) /* NOLINT */
+    #else
+        #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifdef CATCH_TRAP
+    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); }
+#else
+    #define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
+#endif
+
+// #included from: catch_interfaces_runner.h
+#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
+
+namespace Catch {
+    class TestCase;
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+# define CATCH_INTERNAL_STRINGIFY(expr) #expr
+#else
+# define CATCH_INTERNAL_STRINGIFY(expr) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+#endif
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+///////////////////////////////////////////////////////////////////////////////
+// We can speedup compilation significantly by breaking into debugger lower in
+// the callstack, because then we don't have to expand CATCH_BREAK_INTO_DEBUGGER
+// macro in each assertion
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    resultBuilder.react();
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+// This can potentially cause false negative, if the test code catches
+// the exception before it propagates back up to the runner.
+#define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+        ( __catchResult <= expr ).endExpression(); \
+        CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+
+#define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        __catchResult.setExceptionGuard(); \
+        __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        __catchResult.unsetExceptionGuard(); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+#else
+///////////////////////////////////////////////////////////////////////////////
+// In the event of a failure works out if the debugger needs to be invoked
+// and/or an exception thrown and takes appropriate action.
+// This needs to be done as a macro so the debugger will stop in the user
+// source code rather than in Catch library code
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
+    resultBuilder.react();
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        try { \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            ( __catchResult <= expr ).endExpression(); \
+            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
+    if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, expr ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
+    if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        try { \
+            static_cast<void>(expr); \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( ... ) { \
+                __catchResult.captureExpectedException( matcher ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                static_cast<void>(expr); \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( exceptionType ) { \
+                __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            } \
+            catch( ... ) { \
+                __catchResult.useActiveException( resultDisposition ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#else
+    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, log ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << log + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        try { \
+            __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
+        } catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+// #included from: internal/catch_section.h
+#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
+
+// #included from: catch_section_info.h
+#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
+
+// #included from: catch_totals.hpp
+#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}
+
+        Counts operator - ( Counts const& other ) const {
+            Counts diff;
+            diff.passed = passed - other.passed;
+            diff.failed = failed - other.failed;
+            diff.failedButOk = failedButOk - other.failedButOk;
+            return diff;
+        }
+        Counts& operator += ( Counts const& other ) {
+            passed += other.passed;
+            failed += other.failed;
+            failedButOk += other.failedButOk;
+            return *this;
+        }
+
+        std::size_t total() const {
+            return passed + failed + failedButOk;
+        }
+        bool allPassed() const {
+            return failed == 0 && failedButOk == 0;
+        }
+        bool allOk() const {
+            return failed == 0;
+        }
+
+        std::size_t passed;
+        std::size_t failed;
+        std::size_t failedButOk;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const {
+            Totals diff;
+            diff.assertions = assertions - other.assertions;
+            diff.testCases = testCases - other.testCases;
+            return diff;
+        }
+
+        Totals delta( Totals const& prevTotals ) const {
+            Totals diff = *this - prevTotals;
+            if( diff.assertions.failed > 0 )
+                ++diff.testCases.failed;
+            else if( diff.assertions.failedButOk > 0 )
+                ++diff.testCases.failedButOk;
+            else
+                ++diff.testCases.passed;
+            return diff;
+        }
+
+        Totals& operator += ( Totals const& other ) {
+            assertions += other.assertions;
+            testCases += other.testCases;
+            return *this;
+        }
+
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+#include <string>
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& _description = std::string() );
+
+        std::string name;
+        std::string description;
+        SourceLineInfo lineInfo;
+    };
+
+    struct SectionEndInfo {
+        SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds )
+        : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
+        {}
+
+        SectionInfo sectionInfo;
+        Counts prevAssertions;
+        double durationInSeconds;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_timer.h
+#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
+
+#ifdef _MSC_VER
+
+namespace Catch {
+    typedef unsigned long long UInt64;
+}
+#else
+#include <stdint.h>
+namespace Catch {
+    typedef uint64_t UInt64;
+}
+#endif
+
+namespace Catch {
+    class Timer {
+    public:
+        Timer() : m_ticks( 0 ) {}
+        void start();
+        unsigned int getElapsedMicroseconds() const;
+        unsigned int getElapsedMilliseconds() const;
+        double getElapsedSeconds() const;
+
+    private:
+        UInt64 m_ticks;
+    };
+
+} // namespace Catch
+
+#include <string>
+
+namespace Catch {
+
+    class Section : NonCopyable {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        operator bool() const;
+
+    private:
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_SECTION( ... ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
+#else
+    #define INTERNAL_CATCH_SECTION( name, desc ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
+#endif
+
+// #included from: internal/catch_generators.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
+
+#include <vector>
+#include <string>
+#include <stdlib.h>
+
+namespace Catch {
+
+template<typename T>
+struct IGenerator {
+    virtual ~IGenerator() {}
+    virtual T getValue( std::size_t index ) const = 0;
+    virtual std::size_t size () const = 0;
+};
+
+template<typename T>
+class BetweenGenerator : public IGenerator<T> {
+public:
+    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
+
+    virtual T getValue( std::size_t index ) const {
+        return m_from+static_cast<int>( index );
+    }
+
+    virtual std::size_t size() const {
+        return static_cast<std::size_t>( 1+m_to-m_from );
+    }
+
+private:
+
+    T m_from;
+    T m_to;
+};
+
+template<typename T>
+class ValuesGenerator : public IGenerator<T> {
+public:
+    ValuesGenerator(){}
+
+    void add( T value ) {
+        m_values.push_back( value );
+    }
+
+    virtual T getValue( std::size_t index ) const {
+        return m_values[index];
+    }
+
+    virtual std::size_t size() const {
+        return m_values.size();
+    }
+
+private:
+    std::vector<T> m_values;
+};
+
+template<typename T>
+class CompositeGenerator {
+public:
+    CompositeGenerator() : m_totalSize( 0 ) {}
+
+    // *** Move semantics, similar to auto_ptr ***
+    CompositeGenerator( CompositeGenerator& other )
+    :   m_fileInfo( other.m_fileInfo ),
+        m_totalSize( 0 )
+    {
+        move( other );
+    }
+
+    CompositeGenerator& setFileInfo( const char* fileInfo ) {
+        m_fileInfo = fileInfo;
+        return *this;
+    }
+
+    ~CompositeGenerator() {
+        deleteAll( m_composed );
+    }
+
+    operator T () const {
+        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );
+
+        typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
+        typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
+        for( size_t index = 0; it != itEnd; ++it )
+        {
+            const IGenerator<T>* generator = *it;
+            if( overallIndex >= index && overallIndex < index + generator->size() )
+            {
+                return generator->getValue( overallIndex-index );
+            }
+            index += generator->size();
+        }
+        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
+        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
+    }
+
+    void add( const IGenerator<T>* generator ) {
+        m_totalSize += generator->size();
+        m_composed.push_back( generator );
+    }
+
+    CompositeGenerator& then( CompositeGenerator& other ) {
+        move( other );
+        return *this;
+    }
+
+    CompositeGenerator& then( T value ) {
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( value );
+        add( valuesGen );
+        return *this;
+    }
+
+private:
+
+    void move( CompositeGenerator& other ) {
+        m_composed.insert( m_composed.end(), other.m_composed.begin(), other.m_composed.end() );
+        m_totalSize += other.m_totalSize;
+        other.m_composed.clear();
+    }
+
+    std::vector<const IGenerator<T>*> m_composed;
+    std::string m_fileInfo;
+    size_t m_totalSize;
+};
+
+namespace Generators
+{
+    template<typename T>
+    CompositeGenerator<T> between( T from, T to ) {
+        CompositeGenerator<T> generators;
+        generators.add( new BetweenGenerator<T>( from, to ) );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3 ){
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3, T val4 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        valuesGen->add( val4 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+} // end namespace Generators
+
+using namespace Generators;
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_LINESTR2( line ) #line
+#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )
+
+#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )
+
+// #included from: internal/catch_interfaces_exception.h
+#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
+
+#include <string>
+#include <vector>
+
+// #included from: catch_interfaces_registry_hub.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+    struct ITagAliasRegistry;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+
+        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) = 0;
+        virtual void registerListener( Ptr<IReporterFactory> const& factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+    };
+
+    IRegistryHub& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+namespace Catch {
+
+    typedef std::string(*exceptionTranslateFunction)();
+
+    struct IExceptionTranslator;
+    typedef std::vector<const IExceptionTranslator*> ExceptionTranslators;
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const CATCH_OVERRIDE {
+                try {
+                    if( it == itEnd )
+                        throw;
+                    else
+                        return (*it)->translate( it+1, itEnd );
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+    static std::string translatorName( signature ); \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); }\
+    static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// #included from: internal/catch_approx.hpp
+#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+
+#include <cmath>
+#include <limits>
+
+#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+#include <type_traits>
+#endif
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    public:
+        explicit Approx ( double value )
+        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+            m_margin( 0.0 ),
+            m_scale( 1.0 ),
+            m_value( value )
+        {}
+
+        static Approx custom() {
+            return Approx( 0 );
+        }
+
+#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx operator()( T value ) {
+            Approx approx( static_cast<double>(value) );
+            approx.epsilon( m_epsilon );
+            approx.margin( m_margin );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        explicit Approx( T value ): Approx(static_cast<double>(value))
+        {}
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            auto lhs_v = double(lhs);
+            bool relativeOK = std::fabs(lhs_v - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (std::max)(std::fabs(lhs_v), std::fabs(rhs.m_value)));
+            if (relativeOK) {
+                return true;
+            }
+
+            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( T lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator != ( Approx const& lhs, T rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( T lhs, Approx const& rhs ) {
+            return double(lhs) < rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator <= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value < double(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( T lhs, Approx const& rhs ) {
+            return double(lhs) > rhs.m_value || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        friend bool operator >= ( Approx const& lhs, T rhs ) {
+            return lhs.m_value > double(rhs) || lhs == rhs;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& epsilon( T newEpsilon ) {
+            m_epsilon = double(newEpsilon);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& margin( T newMargin ) {
+            m_margin = double(newMargin);
+            return *this;
+        }
+
+        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        Approx& scale( T newScale ) {
+            m_scale = double(newScale);
+            return *this;
+        }
+
+#else
+
+        Approx operator()( double value ) {
+            Approx approx( value );
+            approx.epsilon( m_epsilon );
+            approx.margin( m_margin );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+        friend bool operator == ( double lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            bool relativeOK = std::fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( std::fabs(lhs), std::fabs(rhs.m_value) ) );
+            if (relativeOK) {
+                return true;
+            }
+            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
+        }
+
+        friend bool operator == ( Approx const& lhs, double rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        friend bool operator != ( double lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        friend bool operator != ( Approx const& lhs, double rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        friend bool operator <= ( double lhs, Approx const& rhs ) {
+            return lhs < rhs.m_value || lhs == rhs;
+        }
+
+        friend bool operator <= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value < rhs || lhs == rhs;
+        }
+
+        friend bool operator >= ( double lhs, Approx const& rhs ) {
+            return lhs > rhs.m_value || lhs == rhs;
+        }
+
+        friend bool operator >= ( Approx const& lhs, double rhs ) {
+            return lhs.m_value > rhs || lhs == rhs;
+        }
+
+        Approx& epsilon( double newEpsilon ) {
+            m_epsilon = newEpsilon;
+            return *this;
+        }
+
+        Approx& margin( double newMargin ) {
+            m_margin = newMargin;
+            return *this;
+        }
+
+        Approx& scale( double newScale ) {
+            m_scale = newScale;
+            return *this;
+        }
+#endif
+
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << "Approx( " << Catch::toString( m_value ) << " )";
+            return oss.str();
+        }
+
+    private:
+        double m_epsilon;
+        double m_margin;
+        double m_scale;
+        double m_value;
+    };
+}
+
+template<>
+inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
+    return value.toString();
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_matchers_string.h
+#define TWOBLUECUBES_CATCH_MATCHERS_STRING_H_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        struct CasedString
+        {
+            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+            std::string adjustString( std::string const& str ) const;
+            std::string caseSensitivitySuffix() const;
+
+            CaseSensitive::Choice m_caseSensitivity;
+            std::string m_str;
+        };
+
+        struct StringMatcherBase : MatcherBase<std::string> {
+            StringMatcherBase( std::string const& operation, CasedString const& comparator );
+            virtual std::string describe() const CATCH_OVERRIDE;
+
+            CasedString m_comparator;
+            std::string m_operation;
+        };
+
+        struct EqualsMatcher : StringMatcherBase {
+            EqualsMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct ContainsMatcher : StringMatcherBase {
+            ContainsMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct StartsWithMatcher : StringMatcherBase {
+            StartsWithMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct EndsWithMatcher : StringMatcherBase {
+            EndsWithMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+
+    } // namespace StdString
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+// #included from: internal/catch_matchers_vector.h
+#define TWOBLUECUBES_CATCH_MATCHERS_VECTOR_H_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Vector {
+
+        template<typename T>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T>, T> {
+
+            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
+
+            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+                return std::find(v.begin(), v.end(), m_comparator) != v.end();
+            }
+
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "Contains: " + Catch::toString( m_comparator );
+            }
+
+            T const& m_comparator;
+        };
+
+        template<typename T>
+        struct ContainsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
+
+            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+                // !TBD: see note in EqualsMatcher
+                if (m_comparator.size() > v.size())
+                    return false;
+                for (size_t i = 0; i < m_comparator.size(); ++i)
+                    if (std::find(v.begin(), v.end(), m_comparator[i]) == v.end())
+                        return false;
+                return true;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "Contains: " + Catch::toString( m_comparator );
+            }
+
+            std::vector<T> const& m_comparator;
+        };
+
+        template<typename T>
+        struct EqualsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
+
+            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+                // !TBD: This currently works if all elements can be compared using !=
+                // - a more general approach would be via a compare template that defaults
+                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // - then just call that directly
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != v[i])
+                        return false;
+                return true;
+            }
+            virtual std::string describe() const CATCH_OVERRIDE {
+                return "Equals: " + Catch::toString( m_comparator );
+            }
+            std::vector<T> const& m_comparator;
+        };
+
+    } // namespace Vector
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    template<typename T>
+    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
+        return Vector::ContainsMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T>( comparator );
+    }
+
+    template<typename T>
+    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
+        return Vector::EqualsMatcher<T>( comparator );
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// #included from: internal/catch_interfaces_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+// #included from: catch_tag_alias.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias( std::string const& _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
+// #included from: catch_option.hpp
+#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( CATCH_NULL ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : CATCH_NULL )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = CATCH_NULL;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != CATCH_NULL; }
+        bool none() const { return nullableValue == CATCH_NULL; }
+
+        bool operator !() const { return nullableValue == CATCH_NULL; }
+        operator SafeBool::type() const {
+            return SafeBool::makeSafe( some() );
+        }
+
+    private:
+        T *nullableValue;
+        union {
+            char storage[sizeof(T)];
+
+            // These are here to force alignment for the storage
+            long double dummy1;
+            void (*dummy2)();
+            long double dummy3;
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+            long long dummy4;
+#endif
+        };
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// #included from: internal/catch_test_case_info.h
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
+
+#include <string>
+#include <set>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestCase;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::set<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        TestCaseInfo( TestCaseInfo const& other );
+
+        friend void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::set<std::string> tags;
+        std::set<std::string> lcaseTags;
+        std::string tagsAsString;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestCase* testCase, TestCaseInfo const& info );
+        TestCase( TestCase const& other );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        void swap( TestCase& other );
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+        TestCase& operator = ( TestCase const& other );
+
+    private:
+        Ptr<ITestCase> test;
+    };
+
+    TestCase makeTestCase(  ITestCase* testCase,
+                            std::string const& className,
+                            std::string const& name,
+                            std::string const& description,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+
+#ifdef __OBJC__
+// #included from: internal/catch_objc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public SharedImpl<ITestCase> {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline size_t registerTestMethods() {
+        size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( CATCH_NULL, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                virtual bool match( NSString* arg ) const CATCH_OVERRIDE {
+                    return false;
+                }
+
+                NSString* m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const CATCH_OVERRIDE {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "equals string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "contains string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "starts with: " + Catch::toString( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( NSString* str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                virtual std::string describe() const CATCH_OVERRIDE {
+                    return "ends with: " + Catch::toString( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_TEST_CASE( name, desc )\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
+{\
+return @ name; \
+}\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
+{ \
+return @ desc; \
+} \
+-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
+
+#endif
+
+#ifdef CATCH_IMPL
+
+// !TBD: Move the leak detector code into a separate header
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+class LeakDetector {
+public:
+    LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
+};
+#else
+class LeakDetector {};
+#endif
+
+LeakDetector leakDetector;
+
+// #included from: internal/catch_impl.hpp
+#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
+
+// Collect all the implementation files together here
+// These are the equivalent of what would usually be cpp files
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// #included from: ../catch_session.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
+
+// #included from: internal/catch_commandline.hpp
+#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
+
+// #included from: catch_config.hpp
+#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
+
+// #included from: catch_test_spec_parser.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_test_spec.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_wildcard_pattern.hpp
+#define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+#include <stdexcept>
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_wildcard( NoWildcard ),
+            m_pattern( adjustCase( pattern ) )
+        {
+            if( startsWith( m_pattern, '*' ) ) {
+                m_pattern = m_pattern.substr( 1 );
+                m_wildcard = WildcardAtStart;
+            }
+            if( endsWith( m_pattern, '*' ) ) {
+                m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+                m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+            }
+        }
+        virtual ~WildcardPattern();
+        virtual bool matches( std::string const& str ) const {
+            switch( m_wildcard ) {
+                case NoWildcard:
+                    return m_pattern == adjustCase( str );
+                case WildcardAtStart:
+                    return endsWith( adjustCase( str ), m_pattern );
+                case WildcardAtEnd:
+                    return startsWith( adjustCase( str ), m_pattern );
+                case WildcardAtBothEnds:
+                    return contains( adjustCase( str ), m_pattern );
+            }
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+            throw std::logic_error( "Unknown enum" );
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+        }
+    private:
+        std::string adjustCase( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
+        }
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard;
+        std::string m_pattern;
+    };
+}
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec {
+        struct Pattern : SharedImpl<> {
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+        };
+        class NamePattern : public Pattern {
+        public:
+            NamePattern( std::string const& name )
+            : m_wildcardPattern( toLower( name ), CaseSensitive::No )
+            {}
+            virtual ~NamePattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                return m_wildcardPattern.matches( toLower( testCase.name ) );
+            }
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
+            virtual ~TagPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
+            }
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            ExcludedPattern( Ptr<Pattern> const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
+            virtual ~ExcludedPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
+        private:
+            Ptr<Pattern> m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<Ptr<Pattern> > m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const {
+                // All patterns in a filter must match for the filter to be a match
+                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) {
+                    if( !(*it)->matches( testCase ) )
+                        return false;
+                }
+                return true;
+            }
+        };
+
+    public:
+        bool hasFilters() const {
+            return !m_filters.empty();
+        }
+        bool matches( TestCaseInfo const& testCase ) const {
+            // A TestSpec matches if any filter matches
+            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
+                if( it->matches( testCase ) )
+                    return true;
+            return false;
+        }
+
+    private:
+        std::vector<Filter> m_filters;
+
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode;
+        bool m_exclusion;
+        std::size_t m_start, m_pos;
+        std::string m_arg;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases ) :m_mode(None), m_exclusion(false), m_start(0), m_pos(0), m_tagAliases( &tagAliases ) {}
+
+        TestSpecParser& parse( std::string const& arg ) {
+            m_mode = None;
+            m_exclusion = false;
+            m_start = std::string::npos;
+            m_arg = m_tagAliases->expandAliases( arg );
+            m_escapeChars.clear();
+            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+                visitChar( m_arg[m_pos] );
+            if( m_mode == Name )
+                addPattern<TestSpec::NamePattern>();
+            return *this;
+        }
+        TestSpec testSpec() {
+            addFilter();
+            return m_testSpec;
+        }
+    private:
+        void visitChar( char c ) {
+            if( m_mode == None ) {
+                switch( c ) {
+                case ' ': return;
+                case '~': m_exclusion = true; return;
+                case '[': return startNewMode( Tag, ++m_pos );
+                case '"': return startNewMode( QuotedName, ++m_pos );
+                case '\\': return escape();
+                default: startNewMode( Name, m_pos ); break;
+                }
+            }
+            if( m_mode == Name ) {
+                if( c == ',' ) {
+                    addPattern<TestSpec::NamePattern>();
+                    addFilter();
+                }
+                else if( c == '[' ) {
+                    if( subString() == "exclude:" )
+                        m_exclusion = true;
+                    else
+                        addPattern<TestSpec::NamePattern>();
+                    startNewMode( Tag, ++m_pos );
+                }
+                else if( c == '\\' )
+                    escape();
+            }
+            else if( m_mode == EscapedName )
+                m_mode = Name;
+            else if( m_mode == QuotedName && c == '"' )
+                addPattern<TestSpec::NamePattern>();
+            else if( m_mode == Tag && c == ']' )
+                addPattern<TestSpec::TagPattern>();
+        }
+        void startNewMode( Mode mode, std::size_t start ) {
+            m_mode = mode;
+            m_start = start;
+        }
+        void escape() {
+            if( m_mode == None )
+                m_start = m_pos;
+            m_mode = EscapedName;
+            m_escapeChars.push_back( m_pos );
+        }
+        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
+        template<typename T>
+        void addPattern() {
+            std::string token = subString();
+            for( size_t i = 0; i < m_escapeChars.size(); ++i )
+                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
+            m_escapeChars.clear();
+            if( startsWith( token, "exclude:" ) ) {
+                m_exclusion = true;
+                token = token.substr( 8 );
+            }
+            if( !token.empty() ) {
+                Ptr<TestSpec::Pattern> pattern = new T( token );
+                if( m_exclusion )
+                    pattern = new TestSpec::ExcludedPattern( pattern );
+                m_currentFilter.m_patterns.push_back( pattern );
+            }
+            m_exclusion = false;
+            m_mode = None;
+        }
+        void addFilter() {
+            if( !m_currentFilter.m_patterns.empty() ) {
+                m_testSpec.m_filters.push_back( m_currentFilter );
+                m_currentFilter = TestSpec::Filter();
+            }
+        }
+    };
+    inline TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// #included from: catch_interfaces_config.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct Verbosity { enum Level {
+        NoOutput = 0,
+        Quiet,
+        Normal
+    }; };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : IShared {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+
+    };
+}
+
+// #included from: catch_stream.h
+#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
+
+// #included from: catch_streambuf.h
+#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
+
+#include <streambuf>
+
+namespace Catch {
+
+    class StreamBufBase : public std::streambuf {
+    public:
+        virtual ~StreamBufBase() CATCH_NOEXCEPT;
+    };
+}
+
+#include <streambuf>
+#include <ostream>
+#include <fstream>
+#include <memory>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+    struct IStream {
+        virtual ~IStream() CATCH_NOEXCEPT;
+        virtual std::ostream& stream() const = 0;
+    };
+
+    class FileStream : public IStream {
+        mutable std::ofstream m_ofs;
+    public:
+        FileStream( std::string const& filename );
+        virtual ~FileStream() CATCH_NOEXCEPT;
+    public: // IStream
+        virtual std::ostream& stream() const CATCH_OVERRIDE;
+    };
+
+    class CoutStream : public IStream {
+        mutable std::ostream m_os;
+    public:
+        CoutStream();
+        virtual ~CoutStream() CATCH_NOEXCEPT;
+
+    public: // IStream
+        virtual std::ostream& stream() const CATCH_OVERRIDE;
+    };
+
+    class DebugOutStream : public IStream {
+        CATCH_AUTO_PTR( StreamBufBase ) m_streamBuf;
+        mutable std::ostream m_os;
+    public:
+        DebugOutStream();
+        virtual ~DebugOutStream() CATCH_NOEXCEPT;
+
+    public: // IStream
+        virtual std::ostream& stream() const CATCH_OVERRIDE;
+    };
+}
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <stdexcept>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct ConfigData {
+
+        ConfigData()
+        :   listTests( false ),
+            listTags( false ),
+            listReporters( false ),
+            listTestNamesOnly( false ),
+            listExtraInfo( false ),
+            showSuccessfulTests( false ),
+            shouldDebugBreak( false ),
+            noThrow( false ),
+            showHelp( false ),
+            showInvisibles( false ),
+            filenamesAsTags( false ),
+            libIdentify( false ),
+            abortAfter( -1 ),
+            rngSeed( 0 ),
+            verbosity( Verbosity::Normal ),
+            warnings( WarnAbout::Nothing ),
+            showDurations( ShowDurations::DefaultForReporter ),
+            runOrder( RunTests::InDeclarationOrder ),
+            useColour( UseColour::Auto ),
+            waitForKeypress( WaitForKeypress::Never )
+        {}
+
+        bool listTests;
+        bool listTags;
+        bool listReporters;
+        bool listTestNamesOnly;
+        bool listExtraInfo;
+
+        bool showSuccessfulTests;
+        bool shouldDebugBreak;
+        bool noThrow;
+        bool showHelp;
+        bool showInvisibles;
+        bool filenamesAsTags;
+        bool libIdentify;
+
+        int abortAfter;
+        unsigned int rngSeed;
+
+        Verbosity::Level verbosity;
+        WarnAbout::What warnings;
+        ShowDurations::OrNot showDurations;
+        RunTests::InWhatOrder runOrder;
+        UseColour::YesOrNo useColour;
+        WaitForKeypress::When waitForKeypress;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+
+        std::vector<std::string> reporterNames;
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public SharedImpl<IConfig> {
+    private:
+        Config( Config const& other );
+        Config& operator = ( Config const& other );
+        virtual void dummy();
+    public:
+
+        Config()
+        {}
+
+        Config( ConfigData const& data )
+        :   m_data( data ),
+            m_stream( openStream() )
+        {
+            if( !data.testsOrTags.empty() ) {
+                TestSpecParser parser( ITagAliasRegistry::get() );
+                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
+                    parser.parse( data.testsOrTags[i] );
+                m_testSpec = parser.testSpec();
+            }
+        }
+
+        virtual ~Config() {}
+
+        std::string const& getFilename() const {
+            return m_data.outputFilename ;
+        }
+
+        bool listTests() const { return m_data.listTests; }
+        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
+        bool listTags() const { return m_data.listTags; }
+        bool listReporters() const { return m_data.listReporters; }
+        bool listExtraInfo() const { return m_data.listExtraInfo; }
+
+        std::string getProcessName() const { return m_data.processName; }
+
+        std::vector<std::string> const& getReporterNames() const { return m_data.reporterNames; }
+        std::vector<std::string> const& getSectionsToRun() const CATCH_OVERRIDE { return m_data.sectionsToRun; }
+
+        virtual TestSpec const& testSpec() const CATCH_OVERRIDE { return m_testSpec; }
+
+        bool showHelp() const { return m_data.showHelp; }
+
+        // IConfig interface
+        virtual bool allowThrows() const CATCH_OVERRIDE                 { return !m_data.noThrow; }
+        virtual std::ostream& stream() const CATCH_OVERRIDE             { return m_stream->stream(); }
+        virtual std::string name() const CATCH_OVERRIDE                 { return m_data.name.empty() ? m_data.processName : m_data.name; }
+        virtual bool includeSuccessfulResults() const CATCH_OVERRIDE    { return m_data.showSuccessfulTests; }
+        virtual bool warnAboutMissingAssertions() const CATCH_OVERRIDE  { return m_data.warnings & WarnAbout::NoAssertions; }
+        virtual ShowDurations::OrNot showDurations() const CATCH_OVERRIDE { return m_data.showDurations; }
+        virtual RunTests::InWhatOrder runOrder() const CATCH_OVERRIDE   { return m_data.runOrder; }
+        virtual unsigned int rngSeed() const CATCH_OVERRIDE             { return m_data.rngSeed; }
+        virtual UseColour::YesOrNo useColour() const CATCH_OVERRIDE     { return m_data.useColour; }
+        virtual bool shouldDebugBreak() const CATCH_OVERRIDE { return m_data.shouldDebugBreak; }
+        virtual int abortAfter() const CATCH_OVERRIDE { return m_data.abortAfter; }
+        virtual bool showInvisibles() const CATCH_OVERRIDE { return m_data.showInvisibles; }
+
+    private:
+
+        IStream const* openStream() {
+            if( m_data.outputFilename.empty() )
+                return new CoutStream();
+            else if( m_data.outputFilename[0] == '%' ) {
+                if( m_data.outputFilename == "%debug" )
+                    return new DebugOutStream();
+                else
+                    throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename );
+            }
+            else
+                return new FileStream( m_data.outputFilename );
+        }
+        ConfigData m_data;
+
+        CATCH_AUTO_PTR( IStream const ) m_stream;
+        TestSpec m_testSpec;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_clara.h
+#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
+#undef CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+// Declare Clara inside the Catch namespace
+#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
+// #included from: ../external/clara.h
+
+// Version 0.0.2.4
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
+
+#ifndef STITCH_CLARA_OPEN_NAMESPACE
+#define TWOBLUECUBES_CLARA_H_INCLUDED
+#define STITCH_CLARA_OPEN_NAMESPACE
+#define STITCH_CLARA_CLOSE_NAMESPACE
+#else
+#define STITCH_CLARA_CLOSE_NAMESPACE }
+#endif
+
+#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
+
+// ----------- #included from tbc_text_format.h -----------
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
+#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+#define TBC_TEXT_FORMAT_H_INCLUDED
+#endif
+
+#include <string>
+#include <vector>
+#include <sstream>
+#include <algorithm>
+#include <cctype>
+
+// Use optional outer namespace
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 ),
+            tabChar( '\t' )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+        char tabChar;               // If this char is seen the indent is changed to current pos
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            std::string wrappableChars = " [({.,/|\\-";
+            std::size_t indent = _attr.initialIndent != std::string::npos
+                ? _attr.initialIndent
+                : _attr.indent;
+            std::string remainder = _str;
+
+            while( !remainder.empty() ) {
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+                std::size_t tabPos = std::string::npos;
+                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
+                std::size_t pos = remainder.find_first_of( '\n' );
+                if( pos <= width ) {
+                    width = pos;
+                }
+                pos = remainder.find_last_of( _attr.tabChar, width );
+                if( pos != std::string::npos ) {
+                    tabPos = pos;
+                    if( remainder[width] == '\n' )
+                        width--;
+                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
+                }
+
+                if( width == remainder.size() ) {
+                    spliceLine( indent, remainder, width );
+                }
+                else if( remainder[width] == '\n' ) {
+                    spliceLine( indent, remainder, width );
+                    if( width <= 1 || remainder.size() != 1 )
+                        remainder = remainder.substr( 1 );
+                    indent = _attr.indent;
+                }
+                else {
+                    pos = remainder.find_last_of( wrappableChars, width );
+                    if( pos != std::string::npos && pos > 0 ) {
+                        spliceLine( indent, remainder, pos );
+                        if( remainder[0] == ' ' )
+                            remainder = remainder.substr( 1 );
+                    }
+                    else {
+                        spliceLine( indent, remainder, width-1 );
+                        lines.back() += "-";
+                    }
+                    if( lines.size() == 1 )
+                        indent = _attr.indent;
+                    if( tabPos != std::string::npos )
+                        indent += tabPos;
+                }
+            }
+        }
+
+        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
+            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
+            _remainder = _remainder.substr( _pos );
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TBC_TEXT_FORMAT_H_INCLUDED
+
+// ----------- end of #include from tbc_text_format.h -----------
+// ........... back in clara.h
+
+#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
+
+// ----------- #included from clara_compilers.h -----------
+
+#ifndef TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
+#define TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
+
+// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
+// The following features are defined:
+//
+// CLARA_CONFIG_CPP11_NULLPTR : is nullptr supported?
+// CLARA_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
+// CLARA_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
+// CLARA_CONFIG_CPP11_OVERRIDE : is override supported?
+// CLARA_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
+
+// CLARA_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
+
+// CLARA_CONFIG_VARIADIC_MACROS : are variadic macros supported?
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CLARA_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+// All the C++11 features can be disabled with CLARA_CONFIG_NO_CPP11
+
+#ifdef __clang__
+
+#if __has_feature(cxx_nullptr)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+#if __has_feature(cxx_noexcept)
+#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#endif
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+// - otherwise more recent versions define __cplusplus >= 201103L
+// and will get picked up below
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#if (_MSC_VER >= 1600)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
+#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#endif
+
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// C++ language feature support
+
+// catch all support for C++11
+#if defined(__cplusplus) && __cplusplus >= 201103L
+
+#define CLARA_CPP11_OR_GREATER
+
+#if !defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR)
+#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+#ifndef CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#endif
+
+#ifndef CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#endif
+
+#if !defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE)
+#define CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE
+#endif
+#if !defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
+#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#endif // __cplusplus >= 201103L
+
+// Now set the actual defines based on the above + anything the user has configured
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NO_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_NULLPTR
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_NOEXCEPT
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_GENERATED_METHODS
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_OVERRIDE) && !defined(CLARA_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_OVERRIDE
+#endif
+#if defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_UNIQUE_PTR) && !defined(CLARA_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_CPP11)
+#define CLARA_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+// noexcept support:
+#if defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_NOEXCEPT)
+#define CLARA_NOEXCEPT noexcept
+#  define CLARA_NOEXCEPT_IS(x) noexcept(x)
+#else
+#define CLARA_NOEXCEPT throw()
+#  define CLARA_NOEXCEPT_IS(x)
+#endif
+
+// nullptr support
+#ifdef CLARA_CONFIG_CPP11_NULLPTR
+#define CLARA_NULL nullptr
+#else
+#define CLARA_NULL NULL
+#endif
+
+// override support
+#ifdef CLARA_CONFIG_CPP11_OVERRIDE
+#define CLARA_OVERRIDE override
+#else
+#define CLARA_OVERRIDE
+#endif
+
+// unique_ptr support
+#ifdef CLARA_CONFIG_CPP11_UNIQUE_PTR
+#   define CLARA_AUTO_PTR( T ) std::unique_ptr<T>
+#else
+#   define CLARA_AUTO_PTR( T ) std::auto_ptr<T>
+#endif
+
+#endif // TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
+
+// ----------- end of #include from clara_compilers.h -----------
+// ........... back in clara.h
+
+#include <map>
+#include <stdexcept>
+#include <memory>
+
+#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define CLARA_PLATFORM_WINDOWS
+#endif
+
+// Use optional outer namespace
+#ifdef STITCH_CLARA_OPEN_NAMESPACE
+STITCH_CLARA_OPEN_NAMESPACE
+#endif
+
+namespace Clara {
+
+    struct UnpositionalTag {};
+
+    extern UnpositionalTag _;
+
+#ifdef CLARA_CONFIG_MAIN
+    UnpositionalTag _;
+#endif
+
+    namespace Detail {
+
+#ifdef CLARA_CONSOLE_WIDTH
+    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+        using namespace Tbc;
+
+        inline bool startsWith( std::string const& str, std::string const& prefix ) {
+            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
+        }
+
+        template<typename T> struct RemoveConstRef{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
+
+        template<typename T>    struct IsBool       { static const bool value = false; };
+        template<>              struct IsBool<bool> { static const bool value = true; };
+
+        template<typename T>
+        void convertInto( std::string const& _source, T& _dest ) {
+            std::stringstream ss;
+            ss << _source;
+            ss >> _dest;
+            if( ss.fail() )
+                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
+        }
+        inline void convertInto( std::string const& _source, std::string& _dest ) {
+            _dest = _source;
+        }
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( c ) );
+        }
+        inline void convertInto( std::string const& _source, bool& _dest ) {
+            std::string sourceLC = _source;
+            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), toLowerCh );
+            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
+                _dest = true;
+            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
+                _dest = false;
+            else
+                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
+        }
+
+        template<typename ConfigT>
+        struct IArgFunction {
+            virtual ~IArgFunction() {}
+#ifdef CLARA_CONFIG_CPP11_GENERATED_METHODS
+            IArgFunction()                      = default;
+            IArgFunction( IArgFunction const& ) = default;
+#endif
+            virtual void set( ConfigT& config, std::string const& value ) const = 0;
+            virtual bool takesArg() const = 0;
+            virtual IArgFunction* clone() const = 0;
+        };
+
+        template<typename ConfigT>
+        class BoundArgFunction {
+        public:
+            BoundArgFunction() : functionObj( CLARA_NULL ) {}
+            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
+            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : CLARA_NULL ) {}
+            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
+                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL;
+                delete functionObj;
+                functionObj = newFunctionObj;
+                return *this;
+            }
+            ~BoundArgFunction() { delete functionObj; }
+
+            void set( ConfigT& config, std::string const& value ) const {
+                functionObj->set( config, value );
+            }
+            bool takesArg() const { return functionObj->takesArg(); }
+
+            bool isSet() const {
+                return functionObj != CLARA_NULL;
+            }
+        private:
+            IArgFunction<ConfigT>* functionObj;
+        };
+
+        template<typename C>
+        struct NullBinder : IArgFunction<C>{
+            virtual void set( C&, std::string const& ) const {}
+            virtual bool takesArg() const { return true; }
+            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
+        };
+
+        template<typename C, typename M>
+        struct BoundDataMember : IArgFunction<C>{
+            BoundDataMember( M C::* _member ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                convertInto( stringValue, p.*member );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
+            M C::* member;
+        };
+        template<typename C, typename M>
+        struct BoundUnaryMethod : IArgFunction<C>{
+            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( stringValue, value );
+                (p.*member)( value );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
+            void (C::*member)( M );
+        };
+        template<typename C>
+        struct BoundNullaryMethod : IArgFunction<C>{
+            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    (p.*member)();
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
+            void (C::*member)();
+        };
+
+        template<typename C>
+        struct BoundUnaryFunction : IArgFunction<C>{
+            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    function( obj );
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
+            void (*function)( C& );
+        };
+
+        template<typename C, typename T>
+        struct BoundBinaryFunction : IArgFunction<C>{
+            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( stringValue, value );
+                function( obj, value );
+            }
+            virtual bool takesArg() const { return !IsBool<T>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
+            void (*function)( C&, T );
+        };
+
+    } // namespace Detail
+
+    inline std::vector<std::string> argsToVector( int argc, char const* const* const argv ) {
+        std::vector<std::string> args( static_cast<std::size_t>( argc ) );
+        for( std::size_t i = 0; i < static_cast<std::size_t>( argc ); ++i )
+            args[i] = argv[i];
+
+        return args;
+    }
+
+    class Parser {
+        enum Mode { None, MaybeShortOpt, SlashOpt, ShortOpt, LongOpt, Positional };
+        Mode mode;
+        std::size_t from;
+        bool inQuotes;
+    public:
+
+        struct Token {
+            enum Type { Positional, ShortOpt, LongOpt };
+            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
+            Type type;
+            std::string data;
+        };
+
+        Parser() : mode( None ), from( 0 ), inQuotes( false ){}
+
+        void parseIntoTokens( std::vector<std::string> const& args, std::vector<Token>& tokens ) {
+            const std::string doubleDash = "--";
+            for( std::size_t i = 1; i < args.size() && args[i] != doubleDash; ++i )
+                parseIntoTokens( args[i], tokens);
+        }
+
+        void parseIntoTokens( std::string const& arg, std::vector<Token>& tokens ) {
+            for( std::size_t i = 0; i < arg.size(); ++i ) {
+                char c = arg[i];
+                if( c == '"' )
+                    inQuotes = !inQuotes;
+                mode = handleMode( i, c, arg, tokens );
+            }
+            mode = handleMode( arg.size(), '\0', arg, tokens );
+        }
+        Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
+            switch( mode ) {
+                case None: return handleNone( i, c );
+                case MaybeShortOpt: return handleMaybeShortOpt( i, c );
+                case ShortOpt:
+                case LongOpt:
+                case SlashOpt: return handleOpt( i, c, arg, tokens );
+                case Positional: return handlePositional( i, c, arg, tokens );
+                default: throw std::logic_error( "Unknown mode" );
+            }
+        }
+
+        Mode handleNone( std::size_t i, char c ) {
+            if( inQuotes ) {
+                from = i;
+                return Positional;
+            }
+            switch( c ) {
+                case '-': return MaybeShortOpt;
+#ifdef CLARA_PLATFORM_WINDOWS
+                case '/': from = i+1; return SlashOpt;
+#endif
+                default: from = i; return Positional;
+            }
+        }
+        Mode handleMaybeShortOpt( std::size_t i, char c ) {
+            switch( c ) {
+                case '-': from = i+1; return LongOpt;
+                default: from = i; return ShortOpt;
+            }
+        }
+
+        Mode handleOpt( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
+            if( std::string( ":=\0", 3 ).find( c ) == std::string::npos )
+                return mode;
+
+            std::string optName = arg.substr( from, i-from );
+            if( mode == ShortOpt )
+                for( std::size_t j = 0; j < optName.size(); ++j )
+                    tokens.push_back( Token( Token::ShortOpt, optName.substr( j, 1 ) ) );
+            else if( mode == SlashOpt && optName.size() == 1 )
+                tokens.push_back( Token( Token::ShortOpt, optName ) );
+            else
+                tokens.push_back( Token( Token::LongOpt, optName ) );
+            return None;
+        }
+        Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
+            if( inQuotes || std::string( "\0", 1 ).find( c ) == std::string::npos )
+                return mode;
+
+            std::string data = arg.substr( from, i-from );
+            tokens.push_back( Token( Token::Positional, data ) );
+            return None;
+        }
+    };
+
+    template<typename ConfigT>
+    struct CommonArgProperties {
+        CommonArgProperties() {}
+        CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
+
+        Detail::BoundArgFunction<ConfigT> boundField;
+        std::string description;
+        std::string detail;
+        std::string placeholder; // Only value if boundField takes an arg
+
+        bool takesArg() const {
+            return !placeholder.empty();
+        }
+        void validate() const {
+            if( !boundField.isSet() )
+                throw std::logic_error( "option not bound" );
+        }
+    };
+    struct OptionArgProperties {
+        std::vector<std::string> shortNames;
+        std::string longName;
+
+        bool hasShortName( std::string const& shortName ) const {
+            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
+        }
+        bool hasLongName( std::string const& _longName ) const {
+            return _longName == longName;
+        }
+    };
+    struct PositionalArgProperties {
+        PositionalArgProperties() : position( -1 ) {}
+        int position; // -1 means non-positional (floating)
+
+        bool isFixedPositional() const {
+            return position != -1;
+        }
+    };
+
+    template<typename ConfigT>
+    class CommandLine {
+
+        struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties {
+            Arg() {}
+            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : CommonArgProperties<ConfigT>( _boundField ) {}
+
+            using CommonArgProperties<ConfigT>::placeholder; // !TBD
+
+            std::string dbgName() const {
+                if( !longName.empty() )
+                    return "--" + longName;
+                if( !shortNames.empty() )
+                    return "-" + shortNames[0];
+                return "positional args";
+            }
+            std::string commands() const {
+                std::ostringstream oss;
+                bool first = true;
+                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
+                for(; it != itEnd; ++it ) {
+                    if( first )
+                        first = false;
+                    else
+                        oss << ", ";
+                    oss << "-" << *it;
+                }
+                if( !longName.empty() ) {
+                    if( !first )
+                        oss << ", ";
+                    oss << "--" << longName;
+                }
+                if( !placeholder.empty() )
+                    oss << " <" << placeholder << ">";
+                return oss.str();
+            }
+        };
+
+        typedef CLARA_AUTO_PTR( Arg ) ArgAutoPtr;
+
+        friend void addOptName( Arg& arg, std::string const& optName )
+        {
+            if( optName.empty() )
+                return;
+            if( Detail::startsWith( optName, "--" ) ) {
+                if( !arg.longName.empty() )
+                    throw std::logic_error( "Only one long opt may be specified. '"
+                        + arg.longName
+                        + "' already specified, now attempting to add '"
+                        + optName + "'" );
+                arg.longName = optName.substr( 2 );
+            }
+            else if( Detail::startsWith( optName, "-" ) )
+                arg.shortNames.push_back( optName.substr( 1 ) );
+            else
+                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
+        }
+        friend void setPositionalArg( Arg& arg, int position )
+        {
+            arg.position = position;
+        }
+
+        class ArgBuilder {
+        public:
+            ArgBuilder( Arg* arg ) : m_arg( arg ) {}
+
+            // Bind a non-boolean data member (requires placeholder string)
+            template<typename C, typename M>
+            void bind( M C::* field, std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
+                m_arg->placeholder = placeholder;
+            }
+            // Bind a boolean data member (no placeholder required)
+            template<typename C>
+            void bind( bool C::* field ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
+            }
+
+            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
+            template<typename C, typename M>
+            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,M>( unaryMethod );
+                m_arg->placeholder = placeholder;
+            }
+
+            // Bind a method taking a single, boolean argument (no placeholder string required)
+            template<typename C>
+            void bind( void (C::* unaryMethod)( bool ) ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,bool>( unaryMethod );
+            }
+
+            // Bind a method that takes no arguments (will be called if opt is present)
+            template<typename C>
+            void bind( void (C::* nullaryMethod)() ) {
+                m_arg->boundField = new Detail::BoundNullaryMethod<C>( nullaryMethod );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
+            template<typename C>
+            void bind( void (* unaryFunction)( C& ) ) {
+                m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
+            template<typename C, typename T>
+            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
+                m_arg->placeholder = placeholder;
+            }
+
+            ArgBuilder& describe( std::string const& description ) {
+                m_arg->description = description;
+                return *this;
+            }
+            ArgBuilder& detail( std::string const& detail ) {
+                m_arg->detail = detail;
+                return *this;
+            }
+
+        protected:
+            Arg* m_arg;
+        };
+
+        class OptBuilder : public ArgBuilder {
+        public:
+            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
+            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}
+
+            OptBuilder& operator[]( std::string const& optName ) {
+                addOptName( *ArgBuilder::m_arg, optName );
+                return *this;
+            }
+        };
+
+    public:
+
+        CommandLine()
+        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
+            m_highestSpecifiedArgPosition( 0 ),
+            m_throwOnUnrecognisedTokens( false )
+        {}
+        CommandLine( CommandLine const& other )
+        :   m_boundProcessName( other.m_boundProcessName ),
+            m_options ( other.m_options ),
+            m_positionalArgs( other.m_positionalArgs ),
+            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
+            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
+        {
+            if( other.m_floatingArg.get() )
+                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
+        }
+
+        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
+            m_throwOnUnrecognisedTokens = shouldThrow;
+            return *this;
+        }
+
+        OptBuilder operator[]( std::string const& optName ) {
+            m_options.push_back( Arg() );
+            addOptName( m_options.back(), optName );
+            OptBuilder builder( &m_options.back() );
+            return builder;
+        }
+
+        ArgBuilder operator[]( int position ) {
+            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
+            if( position > m_highestSpecifiedArgPosition )
+                m_highestSpecifiedArgPosition = position;
+            setPositionalArg( m_positionalArgs[position], position );
+            ArgBuilder builder( &m_positionalArgs[position] );
+            return builder;
+        }
+
+        // Invoke this with the _ instance
+        ArgBuilder operator[]( UnpositionalTag ) {
+            if( m_floatingArg.get() )
+                throw std::logic_error( "Only one unpositional argument can be added" );
+            m_floatingArg.reset( new Arg() );
+            ArgBuilder builder( m_floatingArg.get() );
+            return builder;
+        }
+
+        template<typename C, typename M>
+        void bindProcessName( M C::* field ) {
+            m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
+        }
+        template<typename C, typename M>
+        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
+            m_boundProcessName = new Detail::BoundUnaryMethod<C,M>( _unaryMethod );
+        }
+
+        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
+            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
+            std::size_t maxWidth = 0;
+            for( it = itBegin; it != itEnd; ++it )
+                maxWidth = (std::max)( maxWidth, it->commands().size() );
+
+            for( it = itBegin; it != itEnd; ++it ) {
+                Detail::Text usage( it->commands(), Detail::TextAttributes()
+                                                        .setWidth( maxWidth+indent )
+                                                        .setIndent( indent ) );
+                Detail::Text desc( it->description, Detail::TextAttributes()
+                                                        .setWidth( width - maxWidth - 3 ) );
+
+                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
+                    std::string usageCol = i < usage.size() ? usage[i] : "";
+                    os << usageCol;
+
+                    if( i < desc.size() && !desc[i].empty() )
+                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
+                            << desc[i];
+                    os << "\n";
+                }
+            }
+        }
+        std::string optUsage() const {
+            std::ostringstream oss;
+            optUsage( oss );
+            return oss.str();
+        }
+
+        void argSynopsis( std::ostream& os ) const {
+            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
+                if( i > 1 )
+                    os << " ";
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
+                if( it != m_positionalArgs.end() )
+                    os << "<" << it->second.placeholder << ">";
+                else if( m_floatingArg.get() )
+                    os << "<" << m_floatingArg->placeholder << ">";
+                else
+                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
+            }
+            // !TBD No indication of mandatory args
+            if( m_floatingArg.get() ) {
+                if( m_highestSpecifiedArgPosition > 1 )
+                    os << " ";
+                os << "[<" << m_floatingArg->placeholder << "> ...]";
+            }
+        }
+        std::string argSynopsis() const {
+            std::ostringstream oss;
+            argSynopsis( oss );
+            return oss.str();
+        }
+
+        void usage( std::ostream& os, std::string const& procName ) const {
+            validate();
+            os << "usage:\n  " << procName << " ";
+            argSynopsis( os );
+            if( !m_options.empty() ) {
+                os << " [options]\n\nwhere options are: \n";
+                optUsage( os, 2 );
+            }
+            os << "\n";
+        }
+        std::string usage( std::string const& procName ) const {
+            std::ostringstream oss;
+            usage( oss, procName );
+            return oss.str();
+        }
+
+        ConfigT parse( std::vector<std::string> const& args ) const {
+            ConfigT config;
+            parseInto( args, config );
+            return config;
+        }
+
+        std::vector<Parser::Token> parseInto( std::vector<std::string> const& args, ConfigT& config ) const {
+            std::string processName = args.empty() ? std::string() : args[0];
+            std::size_t lastSlash = processName.find_last_of( "/\\" );
+            if( lastSlash != std::string::npos )
+                processName = processName.substr( lastSlash+1 );
+            m_boundProcessName.set( config, processName );
+            std::vector<Parser::Token> tokens;
+            Parser parser;
+            parser.parseIntoTokens( args, tokens );
+            return populate( tokens, config );
+        }
+
+        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            validate();
+            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
+            unusedTokens = populateFixedArgs( unusedTokens, config );
+            unusedTokens = populateFloatingArgs( unusedTokens, config );
+            return unusedTokens;
+        }
+
+        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            std::vector<std::string> errors;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
+                for(; it != itEnd; ++it ) {
+                    Arg const& arg = *it;
+
+                    try {
+                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
+                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
+                            if( arg.takesArg() ) {
+                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
+                                    errors.push_back( "Expected argument to option: " + token.data );
+                                else
+                                    arg.boundField.set( config, tokens[++i].data );
+                            }
+                            else {
+                                arg.boundField.set( config, "true" );
+                            }
+                            break;
+                        }
+                    }
+                    catch( std::exception& ex ) {
+                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
+                    }
+                }
+                if( it == itEnd ) {
+                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
+                        unusedTokens.push_back( token );
+                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
+                        errors.push_back( "unrecognised option: " + token.data );
+                }
+            }
+            if( !errors.empty() ) {
+                std::ostringstream oss;
+                for( std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
+                        it != itEnd;
+                        ++it ) {
+                    if( it != errors.begin() )
+                        oss << "\n";
+                    oss << *it;
+                }
+                throw std::runtime_error( oss.str() );
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            int position = 1;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
+                if( it != m_positionalArgs.end() )
+                    it->second.boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+                if( token.type == Parser::Token::Positional )
+                    position++;
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            if( !m_floatingArg.get() )
+                return tokens;
+            std::vector<Parser::Token> unusedTokens;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                if( token.type == Parser::Token::Positional )
+                    m_floatingArg->boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+            }
+            return unusedTokens;
+        }
+
+        void validate() const
+        {
+            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
+                throw std::logic_error( "No options or arguments specified" );
+
+            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
+                                                            itEnd = m_options.end();
+                    it != itEnd; ++it )
+                it->validate();
+        }
+
+    private:
+        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
+        std::vector<Arg> m_options;
+        std::map<int, Arg> m_positionalArgs;
+        ArgAutoPtr m_floatingArg;
+        int m_highestSpecifiedArgPosition;
+        bool m_throwOnUnrecognisedTokens;
+    };
+
+} // end namespace Clara
+
+STITCH_CLARA_CLOSE_NAMESPACE
+#undef STITCH_CLARA_OPEN_NAMESPACE
+#undef STITCH_CLARA_CLOSE_NAMESPACE
+
+#endif // TWOBLUECUBES_CLARA_H_INCLUDED
+#undef STITCH_CLARA_OPEN_NAMESPACE
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#include <fstream>
+#include <ctime>
+
+namespace Catch {
+
+    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
+    inline void abortAfterX( ConfigData& config, int x ) {
+        if( x < 1 )
+            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
+        config.abortAfter = x;
+    }
+    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
+    inline void addSectionToRun( ConfigData& config, std::string const& sectionName ) { config.sectionsToRun.push_back( sectionName ); }
+    inline void addReporterName( ConfigData& config, std::string const& _reporterName ) { config.reporterNames.push_back( _reporterName ); }
+
+    inline void addWarning( ConfigData& config, std::string const& _warning ) {
+        if( _warning == "NoAssertions" )
+            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
+        else
+            throw std::runtime_error( "Unrecognised warning: '" + _warning + '\'' );
+    }
+    inline void setOrder( ConfigData& config, std::string const& order ) {
+        if( startsWith( "declared", order ) )
+            config.runOrder = RunTests::InDeclarationOrder;
+        else if( startsWith( "lexical", order ) )
+            config.runOrder = RunTests::InLexicographicalOrder;
+        else if( startsWith( "random", order ) )
+            config.runOrder = RunTests::InRandomOrder;
+        else
+            throw std::runtime_error( "Unrecognised ordering: '" + order + '\'' );
+    }
+    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
+        if( seed == "time" ) {
+            config.rngSeed = static_cast<unsigned int>( std::time(0) );
+        }
+        else {
+            std::stringstream ss;
+            ss << seed;
+            ss >> config.rngSeed;
+            if( ss.fail() )
+                throw std::runtime_error( "Argument to --rng-seed should be the word 'time' or a number" );
+        }
+    }
+    inline void setVerbosity( ConfigData& config, int level ) {
+        // !TBD: accept strings?
+        config.verbosity = static_cast<Verbosity::Level>( level );
+    }
+    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
+        config.showDurations = _showDurations
+            ? ShowDurations::Always
+            : ShowDurations::Never;
+    }
+    inline void setUseColour( ConfigData& config, std::string const& value ) {
+        std::string mode = toLower( value );
+
+        if( mode == "yes" )
+            config.useColour = UseColour::Yes;
+        else if( mode == "no" )
+            config.useColour = UseColour::No;
+        else if( mode == "auto" )
+            config.useColour = UseColour::Auto;
+        else
+            throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
+    }
+    inline void setWaitForKeypress( ConfigData& config, std::string const& keypress ) {
+        std::string keypressLc = toLower( keypress );
+        if( keypressLc == "start" )
+            config.waitForKeypress = WaitForKeypress::BeforeStart;
+        else if( keypressLc == "exit" )
+            config.waitForKeypress = WaitForKeypress::BeforeExit;
+        else if( keypressLc == "both" )
+            config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+        else
+            throw std::runtime_error( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
+    };
+
+    inline void forceColour( ConfigData& config ) {
+        config.useColour = UseColour::Yes;
+    }
+    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
+        std::ifstream f( _filename.c_str() );
+        if( !f.is_open() )
+            throw std::domain_error( "Unable to load input file: " + _filename );
+
+        std::string line;
+        while( std::getline( f, line ) ) {
+            line = trim(line);
+            if( !line.empty() && !startsWith( line, '#' ) ) {
+                if( !startsWith( line, '"' ) )
+                    line = '"' + line + '"';
+                addTestOrTags( config, line + ',' );
+            }
+        }
+    }
+
+    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
+
+        using namespace Clara;
+        CommandLine<ConfigData> cli;
+
+        cli.bindProcessName( &ConfigData::processName );
+
+        cli["-?"]["-h"]["--help"]
+            .describe( "display usage information" )
+            .bind( &ConfigData::showHelp );
+
+        cli["-l"]["--list-tests"]
+            .describe( "list all/matching test cases" )
+            .bind( &ConfigData::listTests );
+
+        cli["-t"]["--list-tags"]
+            .describe( "list all/matching tags" )
+            .bind( &ConfigData::listTags );
+
+        cli["-s"]["--success"]
+            .describe( "include successful tests in output" )
+            .bind( &ConfigData::showSuccessfulTests );
+
+        cli["-b"]["--break"]
+            .describe( "break into debugger on failure" )
+            .bind( &ConfigData::shouldDebugBreak );
+
+        cli["-e"]["--nothrow"]
+            .describe( "skip exception tests" )
+            .bind( &ConfigData::noThrow );
+
+        cli["-i"]["--invisibles"]
+            .describe( "show invisibles (tabs, newlines)" )
+            .bind( &ConfigData::showInvisibles );
+
+        cli["-o"]["--out"]
+            .describe( "output filename" )
+            .bind( &ConfigData::outputFilename, "filename" );
+
+        cli["-r"]["--reporter"]
+//            .placeholder( "name[:filename]" )
+            .describe( "reporter to use (defaults to console)" )
+            .bind( &addReporterName, "name" );
+
+        cli["-n"]["--name"]
+            .describe( "suite name" )
+            .bind( &ConfigData::name, "name" );
+
+        cli["-a"]["--abort"]
+            .describe( "abort at first failure" )
+            .bind( &abortAfterFirst );
+
+        cli["-x"]["--abortx"]
+            .describe( "abort after x failures" )
+            .bind( &abortAfterX, "no. failures" );
+
+        cli["-w"]["--warn"]
+            .describe( "enable warnings" )
+            .bind( &addWarning, "warning name" );
+
+// - needs updating if reinstated
+//        cli.into( &setVerbosity )
+//            .describe( "level of verbosity (0=no output)" )
+//            .shortOpt( "v")
+//            .longOpt( "verbosity" )
+//            .placeholder( "level" );
+
+        cli[_]
+            .describe( "which test or tests to use" )
+            .bind( &addTestOrTags, "test name, pattern or tags" );
+
+        cli["-d"]["--durations"]
+            .describe( "show test durations" )
+            .bind( &setShowDurations, "yes|no" );
+
+        cli["-f"]["--input-file"]
+            .describe( "load test names to run from a file" )
+            .bind( &loadTestNamesFromFile, "filename" );
+
+        cli["-#"]["--filenames-as-tags"]
+            .describe( "adds a tag for the filename" )
+            .bind( &ConfigData::filenamesAsTags );
+
+        cli["-c"]["--section"]
+                .describe( "specify section to run" )
+                .bind( &addSectionToRun, "section name" );
+
+        // Less common commands which don't have a short form
+        cli["--list-test-names-only"]
+            .describe( "list all/matching test cases names only" )
+            .bind( &ConfigData::listTestNamesOnly );
+
+        cli["--list-extra-info"]
+            .describe( "list all/matching test cases with more info" )
+            .bind( &ConfigData::listExtraInfo );
+
+        cli["--list-reporters"]
+            .describe( "list all reporters" )
+            .bind( &ConfigData::listReporters );
+
+        cli["--order"]
+            .describe( "test case order (defaults to decl)" )
+            .bind( &setOrder, "decl|lex|rand" );
+
+        cli["--rng-seed"]
+            .describe( "set a specific seed for random numbers" )
+            .bind( &setRngSeed, "'time'|number" );
+
+        cli["--force-colour"]
+            .describe( "force colourised output (deprecated)" )
+            .bind( &forceColour );
+
+        cli["--use-colour"]
+            .describe( "should output be colourised" )
+            .bind( &setUseColour, "yes|no" );
+
+        cli["--libidentify"]
+            .describe( "report name and version according to libidentify standard" )
+            .bind( &ConfigData::libIdentify );
+
+        cli["--wait-for-keypress"]
+                .describe( "waits for a keypress before exiting" )
+                .bind( &setWaitForKeypress, "start|exit|both" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_list.hpp
+#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
+
+// #included from: catch_text.h
+#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
+
+#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
+// #included from: ../external/tbc_text_format.h
+// Only use header guard if we are not using an outer namespace
+#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#  endif
+# else
+#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+# endif
+#endif
+#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#include <string>
+#include <vector>
+#include <sstream>
+
+// Use optional outer namespace
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            const std::string wrappableBeforeChars = "[({<\t";
+            const std::string wrappableAfterChars = "])}>-,./|\\";
+            const std::string wrappableInsteadOfChars = " \n\r";
+            std::string indent = _attr.initialIndent != std::string::npos
+                ? std::string( _attr.initialIndent, ' ' )
+                : std::string( _attr.indent, ' ' );
+
+            typedef std::string::const_iterator iterator;
+            iterator it = _str.begin();
+            const iterator strEnd = _str.end();
+
+            while( it != strEnd ) {
+
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+
+                std::string suffix;
+                std::size_t width = (std::min)( static_cast<size_t>( strEnd-it ), _attr.width-static_cast<size_t>( indent.size() ) );
+                iterator itEnd = it+width;
+                iterator itNext = _str.end();
+
+                iterator itNewLine = std::find( it, itEnd, '\n' );
+                if( itNewLine != itEnd )
+                    itEnd = itNewLine;
+
+                if( itEnd != strEnd  ) {
+                    bool foundWrapPoint = false;
+                    iterator findIt = itEnd;
+                    do {
+                        if( wrappableAfterChars.find( *findIt ) != std::string::npos && findIt != itEnd ) {
+                            itEnd = findIt+1;
+                            itNext = findIt+1;
+                            foundWrapPoint = true;
+                        }
+                        else if( findIt > it && wrappableBeforeChars.find( *findIt ) != std::string::npos ) {
+                            itEnd = findIt;
+                            itNext = findIt;
+                            foundWrapPoint = true;
+                        }
+                        else if( wrappableInsteadOfChars.find( *findIt ) != std::string::npos ) {
+                            itNext = findIt+1;
+                            itEnd = findIt;
+                            foundWrapPoint = true;
+                        }
+                        if( findIt == it )
+                            break;
+                        else
+                            --findIt;
+                    }
+                    while( !foundWrapPoint );
+
+                    if( !foundWrapPoint ) {
+                        // No good wrap char, so we'll break mid word and add a hyphen
+                        --itEnd;
+                        itNext = itEnd;
+                        suffix = "-";
+                    }
+                    else {
+                        while( itEnd > it && wrappableInsteadOfChars.find( *(itEnd-1) ) != std::string::npos )
+                            --itEnd;
+                    }
+                }
+                lines.push_back( indent + std::string( it, itEnd ) + suffix );
+
+                if( indent.size() != _attr.indent )
+                    indent = std::string( _attr.indent, ' ' );
+                it = itNext;
+            }
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+
+namespace Catch {
+    using Tbc::Text;
+    using Tbc::TextAttributes;
+}
+
+// #included from: catch_console_colour.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = Yellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = Yellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour const& other );
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        bool m_moved;
+    };
+
+    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_reporter.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
+
+#include <string>
+#include <ostream>
+#include <map>
+
+namespace Catch
+{
+    struct ReporterConfig {
+        explicit ReporterConfig( Ptr<IConfig const> const& _fullConfig )
+        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+        ReporterConfig( Ptr<IConfig const> const& _fullConfig, std::ostream& _stream )
+        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+        std::ostream& stream() const    { return *m_stream; }
+        Ptr<IConfig const> fullConfig() const { return m_fullConfig; }
+
+    private:
+        std::ostream* m_stream;
+        Ptr<IConfig const> m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        ReporterPreferences()
+        : shouldRedirectStdOut( false )
+        {}
+
+        bool shouldRedirectStdOut;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat() : used( false ) {}
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name ) : name( _name ) {}
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount )
+        :   name( _name ),
+            groupIndex( _groupIndex ),
+            groupsCounts( _groupsCount )
+        {}
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals )
+        :   assertionResult( _assertionResult ),
+            infoMessages( _infoMessages ),
+            totals( _totals )
+        {
+            if( assertionResult.hasMessage() ) {
+                // Copy message into messages list.
+                // !TBD This should have been done earlier, somewhere
+                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+                builder << assertionResult.getMessage();
+                builder.m_info.message = builder.m_stream.str();
+
+                infoMessages.push_back( builder.m_info );
+            }
+        }
+        virtual ~AssertionStats();
+
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = default;
+        AssertionStats& operator = ( AssertionStats && )     = default;
+#  endif
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions )
+        :   sectionInfo( _sectionInfo ),
+            assertions( _assertions ),
+            durationInSeconds( _durationInSeconds ),
+            missingAssertions( _missingAssertions )
+        {}
+        virtual ~SectionStats();
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+#  endif
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting )
+        : testInfo( _testInfo ),
+            totals( _totals ),
+            stdOut( _stdOut ),
+            stdErr( _stdErr ),
+            aborting( _aborting )
+        {}
+        virtual ~TestCaseStats();
+
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+#  endif
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   groupInfo( _groupInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        TestGroupStats( GroupInfo const& _groupInfo )
+        :   groupInfo( _groupInfo ),
+            aborting( false )
+        {}
+        virtual ~TestGroupStats();
+
+#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+#  endif
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   runInfo( _runInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        virtual ~TestRunStats();
+
+#  ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS
+        TestRunStats( TestRunStats const& _other )
+        :   runInfo( _other.runInfo ),
+            totals( _other.totals ),
+            aborting( _other.aborting )
+        {}
+#  else
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+#  endif
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    class MultipleReporters;
+
+    struct IStreamingReporter : IShared {
+        virtual ~IStreamingReporter();
+
+        // Implementing class must also provide the following static method:
+        // static std::string getDescription();
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        virtual MultipleReporters* tryAsMulti() { return CATCH_NULL; }
+    };
+
+    struct IReporterFactory : IShared {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+
+    struct IReporterRegistry {
+        typedef std::map<std::string, Ptr<IReporterFactory> > FactoryMap;
+        typedef std::vector<Ptr<IReporterFactory> > Listeners;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+    Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter );
+
+}
+
+#include <limits>
+#include <algorithm>
+
+namespace Catch {
+
+    inline std::size_t listTests( Config const& config ) {
+
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::size_t matchedTests = 0;
+        TextAttributes nameAttr, descAttr, tagsAttr;
+        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
+        descAttr.setIndent( 4 );
+        tagsAttr.setIndent( 6 );
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
+            if( config.listExtraInfo() ) {
+                Catch::cout() << "    " << testCaseInfo.lineInfo << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Text( description, descAttr ) << std::endl;
+            }
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
+        }
+
+        if( !config.testSpec().hasFilters() )
+            Catch::cout() << pluralise( matchedTests, "test case" ) << '\n' << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTests, "matching test case" ) << '\n' << std::endl;
+        return matchedTests;
+    }
+
+    inline std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( !config.testSpec().hasFilters() )
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            if( startsWith( testCaseInfo.name, '#' ) )
+               Catch::cout() << '"' << testCaseInfo.name << '"';
+            else
+               Catch::cout() << testCaseInfo.name;
+            if ( config.listExtraInfo() )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
+        }
+        return matchedTests;
+    }
+
+    struct TagInfo {
+        TagInfo() : count ( 0 ) {}
+        void add( std::string const& spelling ) {
+            ++count;
+            spellings.insert( spelling );
+        }
+        std::string all() const {
+            std::string out;
+            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
+                        it != itEnd;
+                        ++it )
+                out += "[" + *it + "]";
+            return out;
+        }
+        std::set<std::string> spellings;
+        std::size_t count;
+    };
+
+    inline std::size_t listTags( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
+                                                        tagItEnd = it->getTestCaseInfo().tags.end();
+                    tagIt != tagItEnd;
+                    ++tagIt ) {
+                std::string tagName = *tagIt;
+                std::string lcaseTagName = toLower( tagName );
+                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
+                                                            countItEnd = tagCounts.end();
+                countIt != countItEnd;
+                ++countIt ) {
+            std::ostringstream oss;
+            oss << "  " << std::setw(2) << countIt->second.count << "  ";
+            Text wrapper( countIt->second.all(), TextAttributes()
+                                                    .setInitialIndent( 0 )
+                                                    .setIndent( oss.str().size() )
+                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
+            Catch::cout() << oss.str() << wrapper << '\n';
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+        return tagCounts.size();
+    }
+
+    inline std::size_t listReporters( Config const& /*config*/ ) {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
+        std::size_t maxNameLen = 0;
+        for(it = itBegin; it != itEnd; ++it )
+            maxNameLen = (std::max)( maxNameLen, it->first.size() );
+
+        for(it = itBegin; it != itEnd; ++it ) {
+            Text wrapper( it->second->getDescription(), TextAttributes()
+                                                        .setInitialIndent( 0 )
+                                                        .setIndent( 7+maxNameLen )
+                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
+            Catch::cout() << "  "
+                    << it->first
+                    << ':'
+                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
+                    << wrapper << '\n';
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    inline Option<std::size_t> list( Config const& config ) {
+        Option<std::size_t> listedCount;
+        if( config.listTests() || ( config.listExtraInfo() && !config.listTestNamesOnly() ) )
+            listedCount = listedCount.valueOr(0) + listTests( config );
+        if( config.listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
+        if( config.listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( config );
+        if( config.listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters( config );
+        return listedCount;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_run_context.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
+
+// #included from: catch_test_case_tracker.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <algorithm>
+#include <string>
+#include <assert.h>
+#include <vector>
+#include <stdexcept>
+
+CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    struct NameAndLocation {
+        std::string name;
+        SourceLineInfo location;
+
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+        :   name( _name ),
+            location( _location )
+        {}
+    };
+
+    struct ITracker : SharedImpl<> {
+        virtual ~ITracker();
+
+        // static queries
+        virtual NameAndLocation const& nameAndLocation() const = 0;
+
+        // dynamic queries
+        virtual bool isComplete() const = 0; // Successfully completed or failed
+        virtual bool isSuccessfullyCompleted() const = 0;
+        virtual bool isOpen() const = 0; // Started but not complete
+        virtual bool hasChildren() const = 0;
+
+        virtual ITracker& parent() = 0;
+
+        // actions
+        virtual void close() = 0; // Successfully complete
+        virtual void fail() = 0;
+        virtual void markAsNeedingAnotherRun() = 0;
+
+        virtual void addChild( Ptr<ITracker> const& child ) = 0;
+        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) = 0;
+        virtual void openChild() = 0;
+
+        // Debug/ checking
+        virtual bool isSectionTracker() const = 0;
+        virtual bool isIndexTracker() const = 0;
+    };
+
+    class  TrackerContext {
+
+        enum RunState {
+            NotStarted,
+            Executing,
+            CompletedCycle
+        };
+
+        Ptr<ITracker> m_rootTracker;
+        ITracker* m_currentTracker;
+        RunState m_runState;
+
+    public:
+
+        static TrackerContext& instance() {
+            static TrackerContext s_instance;
+            return s_instance;
+        }
+
+        TrackerContext()
+        :   m_currentTracker( CATCH_NULL ),
+            m_runState( NotStarted )
+        {}
+
+        ITracker& startRun();
+
+        void endRun() {
+            m_rootTracker.reset();
+            m_currentTracker = CATCH_NULL;
+            m_runState = NotStarted;
+        }
+
+        void startCycle() {
+            m_currentTracker = m_rootTracker.get();
+            m_runState = Executing;
+        }
+        void completeCycle() {
+            m_runState = CompletedCycle;
+        }
+
+        bool completedCycle() const {
+            return m_runState == CompletedCycle;
+        }
+        ITracker& currentTracker() {
+            return *m_currentTracker;
+        }
+        void setCurrentTracker( ITracker* tracker ) {
+            m_currentTracker = tracker;
+        }
+    };
+
+    class TrackerBase : public ITracker {
+    protected:
+        enum CycleState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            NeedsAnotherRun,
+            CompletedSuccessfully,
+            Failed
+        };
+        class TrackerHasName {
+            NameAndLocation m_nameAndLocation;
+        public:
+            TrackerHasName( NameAndLocation const& nameAndLocation ) : m_nameAndLocation( nameAndLocation ) {}
+            bool operator ()( Ptr<ITracker> const& tracker ) {
+                return
+                    tracker->nameAndLocation().name == m_nameAndLocation.name &&
+                    tracker->nameAndLocation().location == m_nameAndLocation.location;
+            }
+        };
+        typedef std::vector<Ptr<ITracker> > Children;
+        NameAndLocation m_nameAndLocation;
+        TrackerContext& m_ctx;
+        ITracker* m_parent;
+        Children m_children;
+        CycleState m_runState;
+    public:
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+        :   m_nameAndLocation( nameAndLocation ),
+            m_ctx( ctx ),
+            m_parent( parent ),
+            m_runState( NotStarted )
+        {}
+        virtual ~TrackerBase();
+
+        virtual NameAndLocation const& nameAndLocation() const CATCH_OVERRIDE {
+            return m_nameAndLocation;
+        }
+        virtual bool isComplete() const CATCH_OVERRIDE {
+            return m_runState == CompletedSuccessfully || m_runState == Failed;
+        }
+        virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE {
+            return m_runState == CompletedSuccessfully;
+        }
+        virtual bool isOpen() const CATCH_OVERRIDE {
+            return m_runState != NotStarted && !isComplete();
+        }
+        virtual bool hasChildren() const CATCH_OVERRIDE {
+            return !m_children.empty();
+        }
+
+        virtual void addChild( Ptr<ITracker> const& child ) CATCH_OVERRIDE {
+            m_children.push_back( child );
+        }
+
+        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) CATCH_OVERRIDE {
+            Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( nameAndLocation ) );
+            return( it != m_children.end() )
+                ? it->get()
+                : CATCH_NULL;
+        }
+        virtual ITracker& parent() CATCH_OVERRIDE {
+            assert( m_parent ); // Should always be non-null except for root
+            return *m_parent;
+        }
+
+        virtual void openChild() CATCH_OVERRIDE {
+            if( m_runState != ExecutingChildren ) {
+                m_runState = ExecutingChildren;
+                if( m_parent )
+                    m_parent->openChild();
+            }
+        }
+
+        virtual bool isSectionTracker() const CATCH_OVERRIDE { return false; }
+        virtual bool isIndexTracker() const CATCH_OVERRIDE { return false; }
+
+        void open() {
+            m_runState = Executing;
+            moveToThis();
+            if( m_parent )
+                m_parent->openChild();
+        }
+
+        virtual void close() CATCH_OVERRIDE {
+
+            // Close any still open children (e.g. generators)
+            while( &m_ctx.currentTracker() != this )
+                m_ctx.currentTracker().close();
+
+            switch( m_runState ) {
+                case NotStarted:
+                case CompletedSuccessfully:
+                case Failed:
+                    throw std::logic_error( "Illogical state" );
+
+                case NeedsAnotherRun:
+                    break;;
+
+                case Executing:
+                    m_runState = CompletedSuccessfully;
+                    break;
+                case ExecutingChildren:
+                    if( m_children.empty() || m_children.back()->isComplete() )
+                        m_runState = CompletedSuccessfully;
+                    break;
+
+                default:
+                    throw std::logic_error( "Unexpected state" );
+            }
+            moveToParent();
+            m_ctx.completeCycle();
+        }
+        virtual void fail() CATCH_OVERRIDE {
+            m_runState = Failed;
+            if( m_parent )
+                m_parent->markAsNeedingAnotherRun();
+            moveToParent();
+            m_ctx.completeCycle();
+        }
+        virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE {
+            m_runState = NeedsAnotherRun;
+        }
+    private:
+        void moveToParent() {
+            assert( m_parent );
+            m_ctx.setCurrentTracker( m_parent );
+        }
+        void moveToThis() {
+            m_ctx.setCurrentTracker( this );
+        }
+    };
+
+    class SectionTracker : public TrackerBase {
+        std::vector<std::string> m_filters;
+    public:
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+        :   TrackerBase( nameAndLocation, ctx, parent )
+        {
+            if( parent ) {
+                while( !parent->isSectionTracker() )
+                    parent = &parent->parent();
+
+                SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+                addNextFilters( parentSection.m_filters );
+            }
+        }
+        virtual ~SectionTracker();
+
+        virtual bool isSectionTracker() const CATCH_OVERRIDE { return true; }
+
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+            SectionTracker* section = CATCH_NULL;
+
+            ITracker& currentTracker = ctx.currentTracker();
+            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                assert( childTracker );
+                assert( childTracker->isSectionTracker() );
+                section = static_cast<SectionTracker*>( childTracker );
+            }
+            else {
+                section = new SectionTracker( nameAndLocation, ctx, &currentTracker );
+                currentTracker.addChild( section );
+            }
+            if( !ctx.completedCycle() )
+                section->tryOpen();
+            return *section;
+        }
+
+        void tryOpen() {
+            if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
+                open();
+        }
+
+        void addInitialFilters( std::vector<std::string> const& filters ) {
+            if( !filters.empty() ) {
+                m_filters.push_back(""); // Root - should never be consulted
+                m_filters.push_back(""); // Test Case - not a section filter
+                m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+            }
+        }
+        void addNextFilters( std::vector<std::string> const& filters ) {
+            if( filters.size() > 1 )
+                m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
+        }
+    };
+
+    class IndexTracker : public TrackerBase {
+        int m_size;
+        int m_index;
+    public:
+        IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
+        :   TrackerBase( nameAndLocation, ctx, parent ),
+            m_size( size ),
+            m_index( -1 )
+        {}
+        virtual ~IndexTracker();
+
+        virtual bool isIndexTracker() const CATCH_OVERRIDE { return true; }
+
+        static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
+            IndexTracker* tracker = CATCH_NULL;
+
+            ITracker& currentTracker = ctx.currentTracker();
+            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                assert( childTracker );
+                assert( childTracker->isIndexTracker() );
+                tracker = static_cast<IndexTracker*>( childTracker );
+            }
+            else {
+                tracker = new IndexTracker( nameAndLocation, ctx, &currentTracker, size );
+                currentTracker.addChild( tracker );
+            }
+
+            if( !ctx.completedCycle() && !tracker->isComplete() ) {
+                if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
+                    tracker->moveNext();
+                tracker->open();
+            }
+
+            return *tracker;
+        }
+
+        int index() const { return m_index; }
+
+        void moveNext() {
+            m_index++;
+            m_children.clear();
+        }
+
+        virtual void close() CATCH_OVERRIDE {
+            TrackerBase::close();
+            if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
+                m_runState = Executing;
+        }
+    };
+
+    inline ITracker& TrackerContext::startRun() {
+        m_rootTracker = new SectionTracker( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, CATCH_NULL );
+        m_currentTracker = CATCH_NULL;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+using TestCaseTracking::IndexTracker;
+
+} // namespace Catch
+
+CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+
+// #included from: catch_fatal_condition.hpp
+#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
+
+namespace Catch {
+
+    // Report the error condition
+    inline void reportFatal( std::string const& message ) {
+        IContext& context = Catch::getCurrentContext();
+        IResultCapture* resultCapture = context.getResultCapture();
+        resultCapture->handleFatalErrorCondition( message );
+    }
+
+} // namespace Catch
+
+#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+// #included from: catch_windows_h_proxy.h
+
+#define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
+
+#ifdef CATCH_DEFINES_NOMINMAX
+#  define NOMINMAX
+#endif
+#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+#ifdef CATCH_DEFINES_NOMINMAX
+#  undef NOMINMAX
+#endif
+#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#  undef WIN32_LEAN_AND_MEAN
+#endif
+
+
+#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset() {}
+    };
+}
+
+#  else // CATCH_CONFIG_WINDOWS_SEH is defined
+
+namespace Catch {
+
+    struct SignalDefs { DWORD id; const char* name; };
+    extern SignalDefs signalDefs[];
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    SignalDefs signalDefs[] = {
+        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
+        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
+        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
+        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+    };
+
+    struct FatalConditionHandler {
+
+        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+            for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+                if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
+                    reportFatal(signalDefs[i].name);
+                }
+            }
+            // If its not an exception we care about, pass it along.
+            // This stops us from eating debugger breaks etc.
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
+
+        FatalConditionHandler() {
+            isSet = true;
+            // 32k seems enough for Catch to handle stack overflow,
+            // but the value was found experimentally, so there is no strong guarantee
+            guaranteeSize = 32 * 1024;
+            exceptionHandlerHandle = CATCH_NULL;
+            // Register as first handler in current chain
+            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+            // Pass in guarantee size to be filled
+            SetThreadStackGuarantee(&guaranteeSize);
+        }
+
+        static void reset() {
+            if (isSet) {
+                // Unregister handler and restore the old guarantee
+                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
+                SetThreadStackGuarantee(&guaranteeSize);
+                exceptionHandlerHandle = CATCH_NULL;
+                isSet = false;
+            }
+        }
+
+        ~FatalConditionHandler() {
+            reset();
+        }
+    private:
+        static bool isSet;
+        static ULONG guaranteeSize;
+        static PVOID exceptionHandlerHandle;
+    };
+
+    bool FatalConditionHandler::isSet = false;
+    ULONG FatalConditionHandler::guaranteeSize = 0;
+    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
+
+} // namespace Catch
+
+#  endif // CATCH_CONFIG_WINDOWS_SEH
+
+#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+
+#  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
+
+namespace Catch {
+    struct FatalConditionHandler {
+        void reset() {}
+    };
+}
+
+#  else // CATCH_CONFIG_POSIX_SIGNALS is defined
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+    extern SignalDefs signalDefs[];
+    SignalDefs signalDefs[] = {
+            { SIGINT,  "SIGINT - Terminal interrupt signal" },
+            { SIGILL,  "SIGILL - Illegal instruction signal" },
+            { SIGFPE,  "SIGFPE - Floating point error signal" },
+            { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+            { SIGTERM, "SIGTERM - Termination request signal" },
+            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+    struct FatalConditionHandler {
+
+        static bool isSet;
+        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
+        static stack_t oldSigStack;
+        static char altStackMem[SIGSTKSZ];
+
+        static void handleSignal( int sig ) {
+            std::string name = "<unknown signal>";
+            for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+                SignalDefs &def = signalDefs[i];
+                if (sig == def.id) {
+                    name = def.name;
+                    break;
+                }
+            }
+            reset();
+            reportFatal(name);
+            raise( sig );
+        }
+
+        FatalConditionHandler() {
+            isSet = true;
+            stack_t sigStack;
+            sigStack.ss_sp = altStackMem;
+            sigStack.ss_size = SIGSTKSZ;
+            sigStack.ss_flags = 0;
+            sigaltstack(&sigStack, &oldSigStack);
+            struct sigaction sa = { 0 };
+
+            sa.sa_handler = handleSignal;
+            sa.sa_flags = SA_ONSTACK;
+            for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+                sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+            }
+        }
+
+        ~FatalConditionHandler() {
+            reset();
+        }
+        static void reset() {
+            if( isSet ) {
+                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+                    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
+                }
+                // Return the old stack
+                sigaltstack(&oldSigStack, CATCH_NULL);
+                isSet = false;
+            }
+        }
+    };
+
+    bool FatalConditionHandler::isSet = false;
+    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+    stack_t FatalConditionHandler::oldSigStack = {};
+    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
+
+} // namespace Catch
+
+#  endif // CATCH_CONFIG_POSIX_SIGNALS
+
+#endif // not Windows
+
+#include <set>
+#include <string>
+
+namespace Catch {
+
+    class StreamRedirect {
+
+    public:
+        StreamRedirect( std::ostream& stream, std::string& targetString )
+        :   m_stream( stream ),
+            m_prevBuf( stream.rdbuf() ),
+            m_targetString( targetString )
+        {
+            stream.rdbuf( m_oss.rdbuf() );
+        }
+
+        ~StreamRedirect() {
+            m_targetString += m_oss.str();
+            m_stream.rdbuf( m_prevBuf );
+        }
+
+    private:
+        std::ostream& m_stream;
+        std::streambuf* m_prevBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes and cannot use StreamRedirect on its own
+    class StdErrRedirect {
+    public:
+        StdErrRedirect(std::string& targetString)
+        :m_cerrBuf( cerr().rdbuf() ), m_clogBuf(clog().rdbuf()),
+        m_targetString(targetString){
+            cerr().rdbuf(m_oss.rdbuf());
+            clog().rdbuf(m_oss.rdbuf());
+        }
+        ~StdErrRedirect() {
+            m_targetString += m_oss.str();
+            cerr().rdbuf(m_cerrBuf);
+            clog().rdbuf(m_clogBuf);
+        }
+    private:
+        std::streambuf* m_cerrBuf;
+        std::streambuf* m_clogBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+        RunContext( RunContext const& );
+        void operator =( RunContext const& );
+
+    public:
+
+        explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
+        :   m_runInfo( _config->name() ),
+            m_context( getCurrentMutableContext() ),
+            m_activeTestCase( CATCH_NULL ),
+            m_config( _config ),
+            m_reporter( reporter ),
+            m_shouldReportUnexpected ( true )
+        {
+            m_context.setRunner( this );
+            m_context.setConfig( m_config );
+            m_context.setResultCapture( this );
+            m_reporter->testRunStarting( m_runInfo );
+        }
+
+        virtual ~RunContext() {
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
+        }
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
+        }
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
+        }
+
+        Totals runTest( TestCase const& testCase ) {
+            Totals prevTotals = m_totals;
+
+            std::string redirectedCout;
+            std::string redirectedCerr;
+
+            TestCaseInfo testInfo = testCase.getTestCaseInfo();
+
+            m_reporter->testCaseStarting( testInfo );
+
+            m_activeTestCase = &testCase;
+
+            do {
+                ITracker& rootTracker = m_trackerContext.startRun();
+                assert( rootTracker.isSectionTracker() );
+                static_cast<SectionTracker&>( rootTracker ).addInitialFilters( m_config->getSectionsToRun() );
+                do {
+                    m_trackerContext.startCycle();
+                    m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( testInfo.name, testInfo.lineInfo ) );
+                    runCurrentTest( redirectedCout, redirectedCerr );
+                }
+                while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() );
+            }
+            // !TBD: deprecated - this will be replaced by indexed trackers
+            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
+
+            Totals deltaTotals = m_totals.delta( prevTotals );
+            if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) {
+                deltaTotals.assertions.failed++;
+                deltaTotals.testCases.passed--;
+                deltaTotals.testCases.failed++;
+            }
+            m_totals.testCases += deltaTotals.testCases;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        redirectedCout,
+                                                        redirectedCerr,
+                                                        aborting() ) );
+
+            m_activeTestCase = CATCH_NULL;
+            m_testCaseTracker = CATCH_NULL;
+
+            return deltaTotals;
+        }
+
+        Ptr<IConfig const> config() const {
+            return m_config;
+        }
+
+    private: // IResultCapture
+
+        virtual void assertionEnded( AssertionResult const& result ) {
+            if( result.getResultType() == ResultWas::Ok ) {
+                m_totals.assertions.passed++;
+            }
+            else if( !result.isOk() ) {
+                if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                    m_totals.assertions.failedButOk++;
+                else
+                    m_totals.assertions.failed++;
+            }
+
+            // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+            // and should be let to clear themselves out.
+            static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+            // Reset working state
+            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
+            m_lastResult = result;
+        }
+
+        virtual bool lastAssertionPassed()
+        {
+            return m_totals.assertions.passed == (m_prevPassed + 1);
+        }
+
+        virtual void assertionPassed()
+        {
+            m_totals.assertions.passed++;
+            m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}";
+            m_lastAssertionInfo.macroName = "";
+        }
+
+        virtual void assertionRun()
+        {
+            m_prevPassed = m_totals.assertions.passed;
+        }
+
+        virtual bool sectionStarted (
+            SectionInfo const& sectionInfo,
+            Counts& assertions
+        )
+        {
+            ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( sectionInfo.name, sectionInfo.lineInfo ) );
+            if( !sectionTracker.isOpen() )
+                return false;
+            m_activeSections.push_back( &sectionTracker );
+
+            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+            m_reporter->sectionStarting( sectionInfo );
+
+            assertions = m_totals.assertions;
+
+            return true;
+        }
+        bool testForMissingAssertions( Counts& assertions ) {
+            if( assertions.total() != 0 )
+                return false;
+            if( !m_config->warnAboutMissingAssertions() )
+                return false;
+            if( m_trackerContext.currentTracker().hasChildren() )
+                return false;
+            m_totals.assertions.failed++;
+            assertions.failed++;
+            return true;
+        }
+
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) {
+            Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            if( !m_activeSections.empty() ) {
+                m_activeSections.back()->close();
+                m_activeSections.pop_back();
+            }
+
+            m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) );
+            m_messages.clear();
+        }
+
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) {
+            if( m_unfinishedSections.empty() )
+                m_activeSections.back()->fail();
+            else
+                m_activeSections.back()->close();
+            m_activeSections.pop_back();
+
+            m_unfinishedSections.push_back( endInfo );
+        }
+
+        virtual void pushScopedMessage( MessageInfo const& message ) {
+            m_messages.push_back( message );
+        }
+
+        virtual void popScopedMessage( MessageInfo const& message ) {
+            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
+        }
+
+        virtual std::string getCurrentTestName() const {
+            return m_activeTestCase
+                ? m_activeTestCase->getTestCaseInfo().name
+                : std::string();
+        }
+
+        virtual const AssertionResult* getLastResult() const {
+            return &m_lastResult;
+        }
+
+        virtual void exceptionEarlyReported() {
+            m_shouldReportUnexpected = false;
+        }
+
+        virtual void handleFatalErrorCondition( std::string const& message ) {
+            // Don't rebuild the result -- the stringification itself can cause more fatal errors
+            // Instead, fake a result data.
+            AssertionResultData tempResult;
+            tempResult.resultType = ResultWas::FatalErrorCondition;
+            tempResult.message = message;
+            AssertionResult result(m_lastAssertionInfo, tempResult);
+
+            getResultCapture().assertionEnded(result);
+
+            handleUnfinishedSections();
+
+            // Recreate section for test case (as we will lose the one that was in scope)
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+
+            Counts assertions;
+            assertions.failed = 1;
+            SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
+            m_reporter->sectionEnded( testCaseSectionStats );
+
+            TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
+
+            Totals deltaTotals;
+            deltaTotals.testCases.failed = 1;
+            deltaTotals.assertions.failed = 1;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        std::string(),
+                                                        std::string(),
+                                                        false ) );
+            m_totals.testCases.failed++;
+            testGroupEnded( std::string(), m_totals, 1, 1 );
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
+        }
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const {
+            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
+        }
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+            m_reporter->sectionStarting( testCaseSection );
+            Counts prevAssertions = m_totals.assertions;
+            double duration = 0;
+            m_shouldReportUnexpected = true;
+            try {
+                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
+
+                seedRng( *m_config );
+
+                Timer timer;
+                timer.start();
+                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
+                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
+                    StdErrRedirect errRedir( redirectedCerr );
+                    invokeActiveTestCase();
+                }
+                else {
+                    invokeActiveTestCase();
+                }
+                duration = timer.getElapsedSeconds();
+            }
+            catch( TestFailureException& ) {
+                // This just means the test was aborted due to failure
+            }
+            catch(...) {
+                // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+                // are reported without translation at the point of origin.
+                if (m_shouldReportUnexpected) {
+                    makeUnexpectedResultBuilder().useActiveException();
+                }
+            }
+            m_testCaseTracker->close();
+            handleUnfinishedSections();
+            m_messages.clear();
+
+            Counts assertions = m_totals.assertions - prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
+            m_reporter->sectionEnded( testCaseSectionStats );
+        }
+
+        void invokeActiveTestCase() {
+            FatalConditionHandler fatalConditionHandler; // Handle signals
+            m_activeTestCase->invoke();
+            fatalConditionHandler.reset();
+        }
+
+    private:
+
+        ResultBuilder makeUnexpectedResultBuilder() const {
+            return ResultBuilder(   m_lastAssertionInfo.macroName,
+                                    m_lastAssertionInfo.lineInfo,
+                                    m_lastAssertionInfo.capturedExpression,
+                                    m_lastAssertionInfo.resultDisposition );
+        }
+
+        void handleUnfinishedSections() {
+            // If sections ended prematurely due to an exception we stored their
+            // infos here so we can tear them down outside the unwind process.
+            for( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
+                        itEnd = m_unfinishedSections.rend();
+                    it != itEnd;
+                    ++it )
+                sectionEnded( *it );
+            m_unfinishedSections.clear();
+        }
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase;
+        ITracker* m_testCaseTracker;
+        ITracker* m_currentSectionTracker;
+        AssertionResult m_lastResult;
+
+        Ptr<IConfig const> m_config;
+        Totals m_totals;
+        Ptr<IStreamingReporter> m_reporter;
+        std::vector<MessageInfo> m_messages;
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        size_t m_prevPassed;
+        bool m_shouldReportUnexpected;
+    };
+
+    IResultCapture& getResultCapture() {
+        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
+            return *capture;
+        else
+            throw std::logic_error( "No result capture instance" );
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_version.h
+#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+
+    private:
+        void operator=( Version const& );
+    };
+
+    inline Version libraryVersion();
+}
+
+#include <fstream>
+#include <stdlib.h>
+#include <limits>
+
+namespace Catch {
+
+    Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
+        Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );
+        if( !reporter ) {
+            std::ostringstream oss;
+            oss << "No reporter registered with name: '" << reporterName << "'";
+            throw std::domain_error( oss.str() );
+        }
+        return reporter;
+    }
+
+#if !defined(CATCH_CONFIG_DEFAULT_REPORTER)
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+
+    Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
+        std::vector<std::string> reporters = config->getReporterNames();
+        if( reporters.empty() )
+            reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER );
+
+        Ptr<IStreamingReporter> reporter;
+        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
+                it != itEnd;
+                ++it )
+            reporter = addReporter( reporter, createReporter( *it, config ) );
+        return reporter;
+    }
+    Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
+        IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
+        for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
+                it != itEnd;
+                ++it )
+            reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) );
+        return reporters;
+    }
+
+    Totals runTests( Ptr<Config> const& config ) {
+
+        Ptr<IConfig const> iconfig = config.get();
+
+        Ptr<IStreamingReporter> reporter = makeReporter( config );
+        reporter = addListeners( iconfig, reporter );
+
+        RunContext context( iconfig, reporter );
+
+        Totals totals;
+
+        context.testGroupStarting( config->name(), 1, 1 );
+
+        TestSpec testSpec = config->testSpec();
+        if( !testSpec.hasFilters() )
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
+
+        std::vector<TestCase> const& allTestCases = getAllTestCasesSorted( *iconfig );
+        for( std::vector<TestCase>::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end();
+                it != itEnd;
+                ++it ) {
+            if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) )
+                totals += context.runTest( *it );
+            else
+                reporter->skipTest( *it );
+        }
+
+        context.testGroupEnded( iconfig->name(), totals, 1, 1 );
+        return totals;
+    }
+
+    void applyFilenamesAsTags( IConfig const& config ) {
+        std::vector<TestCase> const& tests = getAllTestCasesSorted( config );
+        for(std::size_t i = 0; i < tests.size(); ++i ) {
+            TestCase& test = const_cast<TestCase&>( tests[i] );
+            std::set<std::string> tags = test.tags;
+
+            std::string filename = test.lineInfo.file;
+            std::string::size_type lastSlash = filename.find_last_of( "\\/" );
+            if( lastSlash != std::string::npos )
+                filename = filename.substr( lastSlash+1 );
+
+            std::string::size_type lastDot = filename.find_last_of( '.' );
+            if( lastDot != std::string::npos )
+                filename = filename.substr( 0, lastDot );
+
+            tags.insert( '#' + filename );
+            setTags( test, tags );
+        }
+    }
+
+    class Session : NonCopyable {
+        static bool alreadyInstantiated;
+
+    public:
+
+        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
+
+        Session()
+        : m_cli( makeCommandLineParser() ) {
+            if( alreadyInstantiated ) {
+                std::string msg = "Only one instance of Catch::Session can ever be used";
+                Catch::cerr() << msg << std::endl;
+                throw std::logic_error( msg );
+            }
+            alreadyInstantiated = true;
+        }
+        ~Session() {
+            Catch::cleanUp();
+        }
+
+        void showHelp( std::string const& processName ) {
+            Catch::cout() << "\nCatch v" << libraryVersion() << "\n";
+
+            m_cli.usage( Catch::cout(), processName );
+            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
+        }
+        void libIdentify() {
+            Catch::cout()
+                    << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
+                    << std::left << std::setw(16) << "category: " << "testframework\n"
+                    << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                    << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+        }
+
+        int applyCommandLine( int argc, char const* const* const argv, OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
+            try {
+                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
+                m_unusedTokens = m_cli.parseInto( Clara::argsToVector( argc, argv ), m_configData );
+                if( m_configData.showHelp )
+                    showHelp( m_configData.processName );
+                if( m_configData.libIdentify )
+                    libIdentify();
+                m_config.reset();
+            }
+            catch( std::exception& ex ) {
+                {
+                    Colour colourGuard( Colour::Red );
+                    Catch::cerr()
+                        << "\nError(s) in input:\n"
+                        << Text( ex.what(), TextAttributes().setIndent(2) )
+                        << "\n\n";
+                }
+                m_cli.usage( Catch::cout(), m_configData.processName );
+                return (std::numeric_limits<int>::max)();
+            }
+            return 0;
+        }
+
+        void useConfigData( ConfigData const& _configData ) {
+            m_configData = _configData;
+            m_config.reset();
+        }
+
+        int run( int argc, char const* const* const argv ) {
+
+            int returnCode = applyCommandLine( argc, argv );
+            if( returnCode == 0 )
+                returnCode = run();
+            return returnCode;
+        }
+
+    #if defined(WIN32) && defined(UNICODE)
+        int run( int argc, wchar_t const* const* const argv ) {
+
+            char **utf8Argv = new char *[ argc ];
+
+            for ( int i = 0; i < argc; ++i ) {
+                int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+
+                utf8Argv[ i ] = new char[ bufSize ];
+
+                WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+            }
+
+            int returnCode = applyCommandLine( argc, utf8Argv );
+            if( returnCode == 0 )
+                returnCode = run();
+
+            for ( int i = 0; i < argc; ++i )
+                delete [] utf8Argv[ i ];
+
+            delete [] utf8Argv;
+
+            return returnCode;
+        }
+    #endif
+
+        int run() {
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            int exitCode = runInternal();
+            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+                Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+                static_cast<void>(std::getchar());
+            }
+            return exitCode;
+        }
+
+        Clara::CommandLine<ConfigData> const& cli() const {
+            return m_cli;
+        }
+        std::vector<Clara::Parser::Token> const& unusedTokens() const {
+            return m_unusedTokens;
+        }
+        ConfigData& configData() {
+            return m_configData;
+        }
+        Config& config() {
+            if( !m_config )
+                m_config = new Config( m_configData );
+            return *m_config;
+        }
+    private:
+
+        int runInternal() {
+            if( m_configData.showHelp || m_configData.libIdentify )
+                return 0;
+
+            try
+            {
+                config(); // Force config to be constructed
+
+                seedRng( *m_config );
+
+                if( m_configData.filenamesAsTags )
+                    applyFilenamesAsTags( *m_config );
+
+                // Handle list request
+                if( Option<std::size_t> listed = list( config() ) )
+                    return static_cast<int>( *listed );
+
+                return static_cast<int>( runTests( m_config ).assertions.failed );
+            }
+            catch( std::exception& ex ) {
+                Catch::cerr() << ex.what() << std::endl;
+                return (std::numeric_limits<int>::max)();
+            }
+        }
+
+        Clara::CommandLine<ConfigData> m_cli;
+        std::vector<Clara::Parser::Token> m_unusedTokens;
+        ConfigData m_configData;
+        Ptr<Config> m_config;
+    };
+
+    bool Session::alreadyInstantiated = false;
+
+} // end namespace Catch
+
+// #included from: catch_registry_hub.hpp
+#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
+
+// #included from: catch_test_case_registry_impl.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <set>
+#include <sstream>
+#include <algorithm>
+
+namespace Catch {
+
+    struct RandomNumberGenerator {
+        typedef unsigned int result_type;
+
+        result_type operator()( result_type n ) const { return std::rand() % n; }
+
+#ifdef CATCH_CONFIG_CPP11_SHUFFLE
+        static constexpr result_type min() { return 0; }
+        static constexpr result_type max() { return 1000000; }
+        result_type operator()() const { return std::rand() % max(); }
+#endif
+        template<typename V>
+        static void shuffle( V& vector ) {
+            RandomNumberGenerator rng;
+#ifdef CATCH_CONFIG_CPP11_SHUFFLE
+            std::shuffle( vector.begin(), vector.end(), rng );
+#else
+            std::random_shuffle( vector.begin(), vector.end(), rng );
+#endif
+        }
+    };
+
+    inline std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+
+        std::vector<TestCase> sorted = unsortedTestCases;
+
+        switch( config.runOrder() ) {
+            case RunTests::InLexicographicalOrder:
+                std::sort( sorted.begin(), sorted.end() );
+                break;
+            case RunTests::InRandomOrder:
+                {
+                    seedRng( config );
+                    RandomNumberGenerator::shuffle( sorted );
+                }
+                break;
+            case RunTests::InDeclarationOrder:
+                // already in declaration order
+                break;
+        }
+        return sorted;
+    }
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
+    }
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+        std::set<TestCase> seenFunctions;
+        for( std::vector<TestCase>::const_iterator it = functions.begin(), itEnd = functions.end();
+            it != itEnd;
+            ++it ) {
+            std::pair<std::set<TestCase>::const_iterator, bool> prev = seenFunctions.insert( *it );
+            if( !prev.second ) {
+                std::ostringstream ss;
+
+                ss  << Colour( Colour::Red )
+                    << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n"
+                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << '\n'
+                    << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl;
+
+                throw std::runtime_error(ss.str());
+            }
+        }
+    }
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCase> filtered;
+        filtered.reserve( testCases.size() );
+        for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
+                it != itEnd;
+                ++it )
+            if( matchTest( *it, testSpec, config ) )
+                filtered.push_back( *it );
+        return filtered;
+    }
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        TestRegistry()
+        :   m_currentSortOrder( RunTests::InDeclarationOrder ),
+            m_unnamedCount( 0 )
+        {}
+        virtual ~TestRegistry();
+
+        virtual void registerTest( TestCase const& testCase ) {
+            std::string name = testCase.getTestCaseInfo().name;
+            if( name.empty() ) {
+                std::ostringstream oss;
+                oss << "Anonymous test case " << ++m_unnamedCount;
+                return registerTest( testCase.withName( oss.str() ) );
+            }
+            m_functions.push_back( testCase );
+        }
+
+        virtual std::vector<TestCase> const& getAllTests() const {
+            return m_functions;
+        }
+        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const {
+            if( m_sortedFunctions.empty() )
+                enforceNoDuplicateTestCases( m_functions );
+
+            if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+                m_sortedFunctions = sortTests( config, m_functions );
+                m_currentSortOrder = config.runOrder();
+            }
+            return m_sortedFunctions;
+        }
+
+    private:
+        std::vector<TestCase> m_functions;
+        mutable RunTests::InWhatOrder m_currentSortOrder;
+        mutable std::vector<TestCase> m_sortedFunctions;
+        size_t m_unnamedCount;
+        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
+    public:
+
+        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
+
+        virtual void invoke() const {
+            m_fun();
+        }
+
+    private:
+        virtual ~FreeFunctionTestCase();
+
+        TestFunction m_fun;
+    };
+
+    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
+        std::string className = classOrQualifiedMethodName;
+        if( startsWith( className, '&' ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+    void registerTestCase
+        (   ITestCase* testCase,
+            char const* classOrQualifiedMethodName,
+            NameAndDesc const& nameAndDesc,
+            SourceLineInfo const& lineInfo ) {
+
+        getMutableRegistryHub().registerTest
+            ( makeTestCase
+                (   testCase,
+                    extractClassName( classOrQualifiedMethodName ),
+                    nameAndDesc.name,
+                    nameAndDesc.description,
+                    lineInfo ) );
+    }
+    void registerTestCaseFunction
+        (   TestFunction function,
+            SourceLineInfo const& lineInfo,
+            NameAndDesc const& nameAndDesc ) {
+        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    AutoReg::AutoReg
+        (   TestFunction function,
+            SourceLineInfo const& lineInfo,
+            NameAndDesc const& nameAndDesc ) {
+        registerTestCaseFunction( function, lineInfo, nameAndDesc );
+    }
+
+    AutoReg::~AutoReg() {}
+
+} // end namespace Catch
+
+// #included from: catch_reporter_registry.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        virtual ~ReporterRegistry() CATCH_OVERRIDE {}
+
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
+            FactoryMap::const_iterator it =  m_factories.find( name );
+            if( it == m_factories.end() )
+                return CATCH_NULL;
+            return it->second->create( ReporterConfig( config ) );
+        }
+
+        void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) {
+            m_factories.insert( std::make_pair( name, factory ) );
+        }
+        void registerListener( Ptr<IReporterFactory> const& factory ) {
+            m_listeners.push_back( factory );
+        }
+
+        virtual FactoryMap const& getFactories() const CATCH_OVERRIDE {
+            return m_factories;
+        }
+        virtual Listeners const& getListeners() const CATCH_OVERRIDE {
+            return m_listeners;
+        }
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+// #included from: catch_exception_translator_registry.hpp
+#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry() {
+            deleteAll( m_translators );
+        }
+
+        virtual void registerTranslator( const IExceptionTranslator* translator ) {
+            m_translators.push_back( translator );
+        }
+
+        virtual std::string translateActiveException() const {
+            try {
+#ifdef __OBJC__
+                // In Objective-C try objective-c exceptions first
+                @try {
+                    return tryTranslators();
+                }
+                @catch (NSException *exception) {
+                    return Catch::toString( [exception description] );
+                }
+#else
+                return tryTranslators();
+#endif
+            }
+            catch( TestFailureException& ) {
+                throw;
+            }
+            catch( std::exception& ex ) {
+                return ex.what();
+            }
+            catch( std::string& msg ) {
+                return msg;
+            }
+            catch( const char* msg ) {
+                return msg;
+            }
+            catch(...) {
+                return "Unknown exception";
+            }
+        }
+
+        std::string tryTranslators() const {
+            if( m_translators.empty() )
+                throw;
+            else
+                return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
+        }
+
+    private:
+        std::vector<const IExceptionTranslator*> m_translators;
+    };
+}
+
+// #included from: catch_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        virtual ~TagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
+
+            RegistryHub( RegistryHub const& );
+            void operator=( RegistryHub const& );
+
+        public: // IRegistryHub
+            RegistryHub() {
+            }
+            virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE {
+                return m_reporterRegistry;
+            }
+            virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE {
+                return m_testCaseRegistry;
+            }
+            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE {
+                return m_exceptionTranslatorRegistry;
+            }
+            virtual ITagAliasRegistry const& getTagAliasRegistry() const CATCH_OVERRIDE {
+                return m_tagAliasRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            virtual void registerListener( Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
+                m_reporterRegistry.registerListener( factory );
+            }
+            virtual void registerTest( TestCase const& testInfo ) CATCH_OVERRIDE {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+            virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) CATCH_OVERRIDE {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+        };
+
+        // Single, global, instance
+        inline RegistryHub*& getTheRegistryHub() {
+            static RegistryHub* theRegistryHub = CATCH_NULL;
+            if( !theRegistryHub )
+                theRegistryHub = new RegistryHub();
+            return theRegistryHub;
+        }
+    }
+
+    IRegistryHub& getRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    void cleanUp() {
+        delete getTheRegistryHub();
+        getTheRegistryHub() = CATCH_NULL;
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_notimplemented_exception.hpp
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
+
+#include <sstream>
+
+namespace Catch {
+
+    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
+    :   m_lineInfo( lineInfo ) {
+        std::ostringstream oss;
+        oss << lineInfo << ": function ";
+        oss << "not implemented";
+        m_what = oss.str();
+    }
+
+    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
+        return m_what.c_str();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_context_impl.hpp
+#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
+
+// #included from: catch_stream.hpp
+#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
+
+#include <stdexcept>
+#include <cstdio>
+#include <iostream>
+
+namespace Catch {
+
+    template<typename WriterF, size_t bufferSize=256>
+    class StreamBufImpl : public StreamBufBase {
+        char data[bufferSize];
+        WriterF m_writer;
+
+    public:
+        StreamBufImpl() {
+            setp( data, data + sizeof(data) );
+        }
+
+        ~StreamBufImpl() CATCH_NOEXCEPT {
+            sync();
+        }
+
+    private:
+        int overflow( int c ) {
+            sync();
+
+            if( c != EOF ) {
+                if( pbase() == epptr() )
+                    m_writer( std::string( 1, static_cast<char>( c ) ) );
+                else
+                    sputc( static_cast<char>( c ) );
+            }
+            return 0;
+        }
+
+        int sync() {
+            if( pbase() != pptr() ) {
+                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                setp( pbase(), epptr() );
+            }
+            return 0;
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    FileStream::FileStream( std::string const& filename ) {
+        m_ofs.open( filename.c_str() );
+        if( m_ofs.fail() ) {
+            std::ostringstream oss;
+            oss << "Unable to open file: '" << filename << '\'';
+            throw std::domain_error( oss.str() );
+        }
+    }
+
+    std::ostream& FileStream::stream() const {
+        return m_ofs;
+    }
+
+    struct OutputDebugWriter {
+
+        void operator()( std::string const&str ) {
+            writeToDebugConsole( str );
+        }
+    };
+
+    DebugOutStream::DebugOutStream()
+    :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+        m_os( m_streamBuf.get() )
+    {}
+
+    std::ostream& DebugOutStream::stream() const {
+        return m_os;
+    }
+
+    // Store the streambuf from cout up-front because
+    // cout may get redirected when running tests
+    CoutStream::CoutStream()
+    :   m_os( Catch::cout().rdbuf() )
+    {}
+
+    std::ostream& CoutStream::stream() const {
+        return m_os;
+    }
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+    std::ostream& cout() {
+        return std::cout;
+    }
+    std::ostream& cerr() {
+        return std::cerr;
+    }
+    std::ostream& clog() {
+        return std::clog;
+    }
+#endif
+}
+
+namespace Catch {
+
+    class Context : public IMutableContext {
+
+        Context() : m_config( CATCH_NULL ), m_runner( CATCH_NULL ), m_resultCapture( CATCH_NULL ) {}
+        Context( Context const& );
+        void operator=( Context const& );
+
+    public:
+        virtual ~Context() {
+            deleteAllValues( m_generatorsByTestName );
+        }
+
+    public: // IContext
+        virtual IResultCapture* getResultCapture() {
+            return m_resultCapture;
+        }
+        virtual IRunner* getRunner() {
+            return m_runner;
+        }
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
+            return getGeneratorsForCurrentTest()
+            .getGeneratorInfo( fileInfo, totalSize )
+            .getCurrentIndex();
+        }
+        virtual bool advanceGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            return generators && generators->moveNext();
+        }
+
+        virtual Ptr<IConfig const> getConfig() const {
+            return m_config;
+        }
+
+    public: // IMutableContext
+        virtual void setResultCapture( IResultCapture* resultCapture ) {
+            m_resultCapture = resultCapture;
+        }
+        virtual void setRunner( IRunner* runner ) {
+            m_runner = runner;
+        }
+        virtual void setConfig( Ptr<IConfig const> const& config ) {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IGeneratorsForTest* findGeneratorsForCurrentTest() {
+            std::string testName = getResultCapture()->getCurrentTestName();
+
+            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
+                m_generatorsByTestName.find( testName );
+            return it != m_generatorsByTestName.end()
+                ? it->second
+                : CATCH_NULL;
+        }
+
+        IGeneratorsForTest& getGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            if( !generators ) {
+                std::string testName = getResultCapture()->getCurrentTestName();
+                generators = createGeneratorsForTest();
+                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
+            }
+            return *generators;
+        }
+
+    private:
+        Ptr<IConfig const> m_config;
+        IRunner* m_runner;
+        IResultCapture* m_resultCapture;
+        std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
+    };
+
+    namespace {
+        Context* currentContext = CATCH_NULL;
+    }
+    IMutableContext& getCurrentMutableContext() {
+        if( !currentContext )
+            currentContext = new Context();
+        return *currentContext;
+    }
+    IContext& getCurrentContext() {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext() {
+        delete currentContext;
+        currentContext = CATCH_NULL;
+    }
+}
+
+// #included from: catch_console_colour_impl.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
+
+// #included from: catch_errno_guard.hpp
+#define TWOBLUECUBES_CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+#include <cerrno>
+
+namespace Catch {
+
+    class ErrnoGuard {
+    public:
+        ErrnoGuard():m_oldErrno(errno){}
+        ~ErrnoGuard() { errno = m_oldErrno; }
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+namespace Catch {
+    namespace {
+
+        struct IColourImpl {
+            virtual ~IColourImpl() {}
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+            originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+        }
+
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalForegroundAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
+        }
+        HANDLE stdoutHandle;
+        WORD originalForegroundAttributes;
+        WORD originalBackgroundAttributes;
+    };
+
+    IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+
+        Ptr<IConfig const> config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = !isDebuggerActive()
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? &s_instance
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public IColourImpl {
+    public:
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0;34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
+    private:
+        void setColour( const char* _escapeCode ) {
+            Catch::cout() << '\033' << _escapeCode;
+        }
+    };
+
+    IColourImpl* platformColourInstance() {
+        ErrnoGuard guard;
+        Ptr<IConfig const> config = getCurrentContext().getConfig();
+        UseColour::YesOrNo colourMode = config
+            ? config->useColour()
+            : UseColour::Auto;
+        if( colourMode == UseColour::Auto )
+            colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) )
+                ? UseColour::Yes
+                : UseColour::No;
+        return colourMode == UseColour::Yes
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else  // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
+    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = platformColourInstance();
+        impl->use( _colourCode );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_generators_impl.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <string>
+#include <map>
+
+namespace Catch {
+
+    struct GeneratorInfo : IGeneratorInfo {
+
+        GeneratorInfo( std::size_t size )
+        :   m_size( size ),
+            m_currentIndex( 0 )
+        {}
+
+        bool moveNext() {
+            if( ++m_currentIndex == m_size ) {
+                m_currentIndex = 0;
+                return false;
+            }
+            return true;
+        }
+
+        std::size_t getCurrentIndex() const {
+            return m_currentIndex;
+        }
+
+        std::size_t m_size;
+        std::size_t m_currentIndex;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class GeneratorsForTest : public IGeneratorsForTest {
+
+    public:
+        ~GeneratorsForTest() {
+            deleteAll( m_generatorsInOrder );
+        }
+
+        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
+            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
+            if( it == m_generatorsByName.end() ) {
+                IGeneratorInfo* info = new GeneratorInfo( size );
+                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
+                m_generatorsInOrder.push_back( info );
+                return *info;
+            }
+            return *it->second;
+        }
+
+        bool moveNext() {
+            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
+            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
+            for(; it != itEnd; ++it ) {
+                if( (*it)->moveNext() )
+                    return true;
+            }
+            return false;
+        }
+
+    private:
+        std::map<std::string, IGeneratorInfo*> m_generatorsByName;
+        std::vector<IGeneratorInfo*> m_generatorsInOrder;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest()
+    {
+        return new GeneratorsForTest();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.hpp
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
+
+namespace Catch {
+
+    AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){}
+
+    AssertionInfo::AssertionInfo(   char const * _macroName,
+                                    SourceLineInfo const& _lineInfo,
+                                    char const * _capturedExpression,
+                                    ResultDisposition::Flags _resultDisposition,
+                                    char const * _secondArg)
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        capturedExpression( _capturedExpression ),
+        resultDisposition( _resultDisposition ),
+        secondArg( _secondArg )
+    {}
+
+    AssertionResult::AssertionResult() {}
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    AssertionResult::~AssertionResult() {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return m_info.capturedExpression[0] != 0;
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) {
+        return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"')
+            ? capturedExpression
+            : std::string(capturedExpression) + ", " + secondArg;
+    }
+
+    std::string AssertionResult::getExpression() const {
+        if( isFalseTest( m_info.resultDisposition ) )
+            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
+        else
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+    }
+    std::string AssertionResult::getExpressionInMacro() const {
+        if( m_info.macroName[0] == 0 )
+            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
+        else
+            return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )";
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        return m_resultData.reconstructExpression();
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    std::string AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+    void AssertionResult::discardDecomposedExpression() const {
+        m_resultData.decomposedExpression = CATCH_NULL;
+    }
+
+    void AssertionResult::expandDecomposedExpression() const {
+        m_resultData.reconstructExpression();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_test_case_info.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+#include <cctype>
+
+namespace Catch {
+
+    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+        if( startsWith( tag, '.' ) ||
+            tag == "hide" ||
+            tag == "!hide" )
+            return TestCaseInfo::IsHidden;
+        else if( tag == "!throws" )
+            return TestCaseInfo::Throws;
+        else if( tag == "!shouldfail" )
+            return TestCaseInfo::ShouldFail;
+        else if( tag == "!mayfail" )
+            return TestCaseInfo::MayFail;
+        else if( tag == "!nonportable" )
+            return TestCaseInfo::NonPortable;
+        else
+            return TestCaseInfo::None;
+    }
+    inline bool isReservedTag( std::string const& tag ) {
+        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( tag[0] );
+    }
+    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+        if( isReservedTag( tag ) ) {
+            std::ostringstream ss;
+            ss << Colour(Colour::Red)
+               << "Tag name [" << tag << "] not allowed.\n"
+               << "Tag names starting with non alpha-numeric characters are reserved\n"
+               << Colour(Colour::FileName)
+               << _lineInfo << '\n';
+            throw std::runtime_error(ss.str());
+        }
+    }
+
+    TestCase makeTestCase(  ITestCase* _testCase,
+                            std::string const& _className,
+                            std::string const& _name,
+                            std::string const& _descOrTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden( startsWith( _name, "./" ) ); // Legacy support
+
+        // Parse out tags
+        std::set<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
+            char c = _descOrTags[i];
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( prop == TestCaseInfo::IsHidden )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    tags.insert( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            tags.insert( "hide" );
+            tags.insert( "." );
+        }
+
+        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, info );
+    }
+
+    void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags )
+    {
+        testCaseInfo.tags = tags;
+        testCaseInfo.lcaseTags.clear();
+
+        std::ostringstream oss;
+        for( std::set<std::string>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) {
+            oss << '[' << *it << ']';
+            std::string lcaseTag = toLower( *it );
+            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+            testCaseInfo.lcaseTags.insert( lcaseTag );
+        }
+        testCaseInfo.tagsAsString = oss.str();
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::set<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        setTags( *this, _tags );
+    }
+
+    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
+    :   name( other.name ),
+        className( other.className ),
+        description( other.description ),
+        tags( other.tags ),
+        lcaseTags( other.lcaseTags ),
+        tagsAsString( other.tagsAsString ),
+        lineInfo( other.lineInfo ),
+        properties( other.properties )
+    {}
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
+
+    TestCase::TestCase( TestCase const& other )
+    :   TestCaseInfo( other ),
+        test( other.test )
+    {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::swap( TestCase& other ) {
+        test.swap( other.test );
+        name.swap( other.name );
+        className.swap( other.className );
+        description.swap( other.description );
+        tags.swap( other.tags );
+        lcaseTags.swap( other.lcaseTags );
+        tagsAsString.swap( other.tagsAsString );
+        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
+        std::swap( lineInfo, other.lineInfo );
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+    TestCase& TestCase::operator = ( TestCase const& other ) {
+        TestCase temp( other );
+        swap( temp );
+        return *this;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_version.hpp
+#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    inline Version libraryVersion() {
+        static Version version( 1, 12, 0, "", 0 );
+        return version;
+    }
+
+}
+
+// #included from: catch_message.hpp
+#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   std::string const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info )
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+    ScopedMessage::ScopedMessage( ScopedMessage const& other )
+    : m_info( other.m_info )
+    {}
+
+    ScopedMessage::~ScopedMessage() {
+        if ( !std::uncaught_exception() ){
+            getResultCapture().popScopedMessage(m_info);
+        }
+    }
+
+} // end namespace Catch
+
+// #included from: catch_legacy_reporter_adapter.hpp
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
+
+// #included from: catch_legacy_reporter_adapter.h
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
+
+namespace Catch
+{
+    // Deprecated
+    struct IReporter : IShared {
+        virtual ~IReporter();
+
+        virtual bool shouldRedirectStdout() const = 0;
+
+        virtual void StartTesting() = 0;
+        virtual void EndTesting( Totals const& totals ) = 0;
+        virtual void StartGroup( std::string const& groupName ) = 0;
+        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
+        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
+        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
+        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
+        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
+        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
+        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
+        virtual void Aborted() = 0;
+        virtual void Result( AssertionResult const& result ) = 0;
+    };
+
+    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
+    {
+    public:
+        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
+        virtual ~LegacyReporterAdapter();
+
+        virtual ReporterPreferences getPreferences() const;
+        virtual void noMatchingTestCases( std::string const& );
+        virtual void testRunStarting( TestRunInfo const& );
+        virtual void testGroupStarting( GroupInfo const& groupInfo );
+        virtual void testCaseStarting( TestCaseInfo const& testInfo );
+        virtual void sectionStarting( SectionInfo const& sectionInfo );
+        virtual void assertionStarting( AssertionInfo const& );
+        virtual bool assertionEnded( AssertionStats const& assertionStats );
+        virtual void sectionEnded( SectionStats const& sectionStats );
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
+        virtual void testRunEnded( TestRunStats const& testRunStats );
+        virtual void skipTest( TestCaseInfo const& );
+
+    private:
+        Ptr<IReporter> m_legacyReporter;
+    };
+}
+
+namespace Catch
+{
+    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
+    :   m_legacyReporter( legacyReporter )
+    {}
+    LegacyReporterAdapter::~LegacyReporterAdapter() {}
+
+    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
+        ReporterPreferences prefs;
+        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
+        return prefs;
+    }
+
+    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
+    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
+        m_legacyReporter->StartTesting();
+    }
+    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
+        m_legacyReporter->StartGroup( groupInfo.name );
+    }
+    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        m_legacyReporter->StartTestCase( testInfo );
+    }
+    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
+        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
+    }
+    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
+        // Not on legacy interface
+    }
+
+    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
+            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                    it != itEnd;
+                    ++it ) {
+                if( it->type == ResultWas::Info ) {
+                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
+                    rb << it->message;
+                    rb.setResultType( ResultWas::Info );
+                    AssertionResult result = rb.build();
+                    m_legacyReporter->Result( result );
+                }
+            }
+        }
+        m_legacyReporter->Result( assertionStats.assertionResult );
+        return true;
+    }
+    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
+        if( sectionStats.missingAssertions )
+            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
+        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
+    }
+    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        m_legacyReporter->EndTestCase
+            (   testCaseStats.testInfo,
+                testCaseStats.totals,
+                testCaseStats.stdOut,
+                testCaseStats.stdErr );
+    }
+    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        if( testGroupStats.aborting )
+            m_legacyReporter->Aborted();
+        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
+    }
+    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
+        m_legacyReporter->EndTesting( testRunStats.totals );
+    }
+    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
+    }
+}
+
+// #included from: catch_timer.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#endif
+
+#ifdef CATCH_PLATFORM_WINDOWS
+
+#else
+
+#include <sys/time.h>
+
+#endif
+
+namespace Catch {
+
+    namespace {
+#ifdef CATCH_PLATFORM_WINDOWS
+        UInt64 getCurrentTicks() {
+            static UInt64 hz=0, hzo=0;
+            if (!hz) {
+                QueryPerformanceFrequency( reinterpret_cast<LARGE_INTEGER*>( &hz ) );
+                QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &hzo ) );
+            }
+            UInt64 t;
+            QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &t ) );
+            return ((t-hzo)*1000000)/hz;
+        }
+#else
+        UInt64 getCurrentTicks() {
+            timeval t;
+            gettimeofday(&t,CATCH_NULL);
+            return static_cast<UInt64>( t.tv_sec ) * 1000000ull + static_cast<UInt64>( t.tv_usec );
+        }
+#endif
+    }
+
+    void Timer::start() {
+        m_ticks = getCurrentTicks();
+    }
+    unsigned int Timer::getElapsedMicroseconds() const {
+        return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
+    }
+    unsigned int Timer::getElapsedMilliseconds() const {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    double Timer::getElapsedSeconds() const {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// #included from: catch_common.hpp
+#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
+
+#include <cstring>
+#include <cctype>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( std::string const& s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    char toLowerCh(char c) {
+        return static_cast<char>( std::tolower( c ) );
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+    SourceLineInfo::SourceLineInfo() : file(""), line( 0 ){}
+    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
+    :   file( _file ),
+        line( _line )
+    {}
+    bool SourceLineInfo::empty() const {
+        return file[0] == '\0';
+    }
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const {
+        return line < other.line || ( line == other.line && (std::strcmp(file, other.file) < 0));
+    }
+
+    void seedRng( IConfig const& config ) {
+        if( config.rngSeed() != 0 )
+            std::srand( config.rngSeed() );
+    }
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
+        std::ostringstream oss;
+        oss << locationInfo << ": Internal Catch error: '" << message << '\'';
+        if( alwaysTrue() )
+            throw std::logic_error( oss.str() );
+    }
+}
+
+// #included from: catch_section.hpp
+#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name,
+            std::string const& _description )
+    :   name( _name ),
+        description( _description ),
+        lineInfo( _lineInfo )
+    {}
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
+#endif
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
+            if( std::uncaught_exception() )
+                getResultCapture().sectionEndedEarly( endInfo );
+            else
+                getResultCapture().sectionEnded( endInfo );
+        }
+    }
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_debugger.hpp
+#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #include <assert.h>
+    #include <stdbool.h>
+    #include <sys/types.h>
+    #include <unistd.h>
+    #include <sys/sysctl.h>
+
+    namespace Catch{
+
+        // The following function is taken directly from the following technical note:
+        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+
+            int                 mib[4];
+            struct kinfo_proc   info;
+            size_t              size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0 ) {
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+    } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    #include <fstream>
+    #include <string>
+
+    namespace Catch{
+        // The standard POSIX way of detecting a debugger is to attempt to
+        // ptrace() the process, but this needs to be done from a child and not
+        // this process itself to still allow attaching to this process later
+        // if wanted, so is rather heavy. Under Linux we have the PID of the
+        // "debugger" (which doesn't need to be gdb, of course, it could also
+        // be strace, for example) in /proc/$PID/status, so just get it from
+        // there instead.
+        bool isDebuggerActive(){
+            // Libstdc++ has a bug, where std::ifstream sets errno to 0
+            // This way our users can properly assert over errno values
+            ErrnoGuard guard;
+            std::ifstream in("/proc/self/status");
+            for( std::string line; std::getline(in, line); ) {
+                static const int PREFIX_LEN = 11;
+                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+                    // We're traced if the PID is not 0 and no other PID starts
+                    // with 0 digit, so it's enough to check for just a single
+                    // character.
+                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+                }
+            }
+
+            return false;
+        }
+    } // namespace Catch
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       inline bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+
+#ifdef CATCH_PLATFORM_WINDOWS
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+#else
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
+        }
+    }
+#endif // Platform
+
+// #included from: catch_tostring.hpp
+#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
+
+namespace Catch {
+
+namespace Detail {
+
+    const std::string unprintableString = "{?}";
+
+    namespace {
+        const int hexThreshold = 255;
+
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                union _{
+                    int asInt;
+                    char asChar[sizeof (int)];
+                } u;
+
+                u.asInt = 1;
+                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size )
+    {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        std::ostringstream os;
+        os << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return os.str();
+    }
+}
+
+std::string toString( std::string const& value ) {
+    std::string s = value;
+    if( getCurrentContext().getConfig()->showInvisibles() ) {
+        for(size_t i = 0; i < s.size(); ++i ) {
+            std::string subs;
+            switch( s[i] ) {
+            case '\n': subs = "\\n"; break;
+            case '\t': subs = "\\t"; break;
+            default: break;
+            }
+            if( !subs.empty() ) {
+                s = s.substr( 0, i ) + subs + s.substr( i+1 );
+                ++i;
+            }
+        }
+    }
+    return '"' + s + '"';
+}
+std::string toString( std::wstring const& value ) {
+
+    std::string s;
+    s.reserve( value.size() );
+    for(size_t i = 0; i < value.size(); ++i )
+        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
+    return Catch::toString( s );
+}
+
+std::string toString( const char* const value ) {
+    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
+}
+
+std::string toString( char* const value ) {
+    return Catch::toString( static_cast<const char*>( value ) );
+}
+
+std::string toString( const wchar_t* const value )
+{
+    return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
+}
+
+std::string toString( wchar_t* const value )
+{
+    return Catch::toString( static_cast<const wchar_t*>( value ) );
+}
+
+std::string toString( int value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+
+std::string toString( unsigned long value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+
+std::string toString( unsigned int value ) {
+    return Catch::toString( static_cast<unsigned long>( value ) );
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    std::ostringstream oss;
+    oss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = oss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+std::string toString( const double value ) {
+    return fpToString( value, 10 );
+}
+std::string toString( const float value ) {
+    return fpToString( value, 5 ) + 'f';
+}
+
+std::string toString( bool value ) {
+    return value ? "true" : "false";
+}
+
+std::string toString( char value ) {
+    if ( value == '\r' )
+        return "'\\r'";
+    if ( value == '\f' )
+        return "'\\f'";
+    if ( value == '\n' )
+        return "'\\n'";
+    if ( value == '\t' )
+        return "'\\t'";
+    if ( '\0' <= value && value < ' ' )
+        return toString( static_cast<unsigned int>( value ) );
+    char chstr[] = "' '";
+    chstr[1] = value;
+    return chstr;
+}
+
+std::string toString( signed char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+std::string toString( unsigned char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+std::string toString( long long value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+std::string toString( unsigned long long value ) {
+    std::ostringstream oss;
+    oss << value;
+    if( value > Detail::hexThreshold )
+        oss << " (0x" << std::hex << value << ')';
+    return oss.str();
+}
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t ) {
+    return "nullptr";
+}
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSString * CATCH_ARC_STRONG & nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSObject* const& nsObject ) {
+        return toString( [nsObject description] );
+    }
+#endif
+
+} // end namespace Catch
+
+// #included from: catch_result_builder.hpp
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
+
+namespace Catch {
+
+    ResultBuilder::ResultBuilder(   char const* macroName,
+                                    SourceLineInfo const& lineInfo,
+                                    char const* capturedExpression,
+                                    ResultDisposition::Flags resultDisposition,
+                                    char const* secondArg )
+    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition, secondArg ),
+        m_shouldDebugBreak( false ),
+        m_shouldThrow( false ),
+        m_guardException( false ),
+        m_usedStream( false )
+    {}
+
+    ResultBuilder::~ResultBuilder() {
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+        if ( m_guardException ) {
+            stream().oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+            captureResult( ResultWas::ThrewException );
+            getCurrentContext().getResultCapture()->exceptionEarlyReported();
+        }
+#endif
+    }
+
+    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
+        m_data.resultType = result;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setResultType( bool result ) {
+        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
+        return *this;
+    }
+
+    void ResultBuilder::endExpression( DecomposedExpression const& expr ) {
+        // Flip bool results if FalseTest flag is set
+        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
+            m_data.negate( expr.isBinaryExpression() );
+        }
+
+        getResultCapture().assertionRun();
+
+        if(getCurrentContext().getConfig()->includeSuccessfulResults() || m_data.resultType != ResultWas::Ok)
+        {
+            AssertionResult result = build( expr );
+            handleResult( result );
+        }
+        else
+            getResultCapture().assertionPassed();
+    }
+
+    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
+        m_assertionInfo.resultDisposition = resultDisposition;
+        stream().oss << Catch::translateActiveException();
+        captureResult( ResultWas::ThrewException );
+    }
+
+    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
+        setResultType( resultType );
+        captureExpression();
+    }
+
+    void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) {
+        if( expectedMessage.empty() )
+            captureExpectedException( Matchers::Impl::MatchAllOf<std::string>() );
+        else
+            captureExpectedException( Matchers::Equals( expectedMessage ) );
+    }
+
+    void ResultBuilder::captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher ) {
+
+        assert( !isFalseTest( m_assertionInfo.resultDisposition ) );
+        AssertionResultData data = m_data;
+        data.resultType = ResultWas::Ok;
+        data.reconstructedExpression = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
+
+        std::string actualMessage = Catch::translateActiveException();
+        if( !matcher.match( actualMessage ) ) {
+            data.resultType = ResultWas::ExpressionFailed;
+            data.reconstructedExpression = actualMessage;
+        }
+        AssertionResult result( m_assertionInfo, data );
+        handleResult( result );
+    }
+
+    void ResultBuilder::captureExpression() {
+        AssertionResult result = build();
+        handleResult( result );
+    }
+
+    void ResultBuilder::handleResult( AssertionResult const& result )
+    {
+        getResultCapture().assertionEnded( result );
+
+        if( !result.isOk() ) {
+            if( getCurrentContext().getConfig()->shouldDebugBreak() )
+                m_shouldDebugBreak = true;
+            if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) )
+                m_shouldThrow = true;
+        }
+    }
+
+    void ResultBuilder::react() {
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+        if (m_shouldDebugBreak) {
+            ///////////////////////////////////////////////////////////////////
+            // To inspect the state during test, you need to go one level up the callstack
+            // To go back to the test and change execution, jump over the throw statement
+            ///////////////////////////////////////////////////////////////////
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+#endif
+        if( m_shouldThrow )
+            throw Catch::TestFailureException();
+    }
+
+    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
+    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
+
+    AssertionResult ResultBuilder::build() const
+    {
+        return build( *this );
+    }
+
+    // CAVEAT: The returned AssertionResult stores a pointer to the argument expr,
+    //         a temporary DecomposedExpression, which in turn holds references to
+    //         operands, possibly temporary as well.
+    //         It should immediately be passed to handleResult; if the expression
+    //         needs to be reported, its string expansion must be composed before
+    //         the temporaries are destroyed.
+    AssertionResult ResultBuilder::build( DecomposedExpression const& expr ) const
+    {
+        assert( m_data.resultType != ResultWas::Unknown );
+        AssertionResultData data = m_data;
+
+        if(m_usedStream)
+            data.message = m_stream().oss.str();
+        data.decomposedExpression = &expr; // for lazy reconstruction
+        return AssertionResult( m_assertionInfo, data );
+    }
+
+    void ResultBuilder::reconstructExpression( std::string& dest ) const {
+        dest = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
+    }
+
+    void ResultBuilder::setExceptionGuard() {
+        m_guardException = true;
+    }
+    void ResultBuilder::unsetExceptionGuard() {
+        m_guardException = false;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_tag_alias_registry.hpp
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
+        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return it->second;
+        else
+            return Option<TagAlias>();
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
+                it != itEnd;
+                ++it ) {
+            std::size_t pos = expandedTestSpec.find( it->first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    it->second.tag +
+                                    expandedTestSpec.substr( pos + it->first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+
+        if( !startsWith( alias, "[@" ) || !endsWith( alias, ']' ) ) {
+            std::ostringstream oss;
+            oss << Colour( Colour::Red )
+                << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n"
+                << Colour( Colour::FileName )
+                << lineInfo << '\n';
+            throw std::domain_error( oss.str().c_str() );
+        }
+        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
+            std::ostringstream oss;
+            oss << Colour( Colour::Red )
+                << "error: tag alias, \"" << alias << "\" already registered.\n"
+                << "\tFirst seen at "
+                << Colour( Colour::Red ) << find(alias)->lineInfo << '\n'
+                << Colour( Colour::Red ) << "\tRedefined at "
+                << Colour( Colour::FileName) << lineInfo << '\n';
+            throw std::domain_error( oss.str().c_str() );
+        }
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
+        getMutableRegistryHub().registerTagAlias( alias, tag, lineInfo );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_matchers_string.hpp
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_str( adjustString( str ) )
+        {}
+        std::string CasedString::adjustString( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? toLower( str )
+                   : str;
+        }
+        std::string CasedString::caseSensitivitySuffix() const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? " (case insensitive)"
+                   : std::string();
+        }
+
+        StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
+        : m_comparator( comparator ),
+          m_operation( operation ) {
+        }
+
+        std::string StringMatcherBase::describe() const {
+            std::string description;
+            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                        m_comparator.caseSensitivitySuffix().size());
+            description += m_operation;
+            description += ": \"";
+            description += m_comparator.m_str;
+            description += "\"";
+            description += m_comparator.caseSensitivitySuffix();
+            return description;
+        }
+
+        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+        bool EqualsMatcher::match( std::string const& source ) const {
+            return m_comparator.adjustString( source ) == m_comparator.m_str;
+        }
+
+        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+        bool ContainsMatcher::match( std::string const& source ) const {
+            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
+
+        bool StartsWithMatcher::match( std::string const& source ) const {
+            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+        bool EndsWithMatcher::match( std::string const& source ) const {
+            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+    } // namespace StdString
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+        return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
+    }
+
+} // namespace Matchers
+} // namespace Catch
+// #included from: ../reporters/catch_reporter_multi.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+namespace Catch {
+
+class MultipleReporters : public SharedImpl<IStreamingReporter> {
+    typedef std::vector<Ptr<IStreamingReporter> > Reporters;
+    Reporters m_reporters;
+
+public:
+    void add( Ptr<IStreamingReporter> const& reporter ) {
+        m_reporters.push_back( reporter );
+    }
+
+public: // IStreamingReporter
+
+    virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
+        return m_reporters[0]->getPreferences();
+    }
+
+    virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->noMatchingTestCases( spec );
+    }
+
+    virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testRunStarting( testRunInfo );
+    }
+
+    virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testGroupStarting( groupInfo );
+    }
+
+    virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testCaseStarting( testInfo );
+    }
+
+    virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->sectionStarting( sectionInfo );
+    }
+
+    virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->assertionStarting( assertionInfo );
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+        bool clearBuffer = false;
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            clearBuffer |= (*it)->assertionEnded( assertionStats );
+        return clearBuffer;
+    }
+
+    virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->sectionEnded( sectionStats );
+    }
+
+    virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testCaseEnded( testCaseStats );
+    }
+
+    virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testGroupEnded( testGroupStats );
+    }
+
+    virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->testRunEnded( testRunStats );
+    }
+
+    virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
+        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+                it != itEnd;
+                ++it )
+            (*it)->skipTest( testInfo );
+    }
+
+    virtual MultipleReporters* tryAsMulti() CATCH_OVERRIDE {
+        return this;
+    }
+
+};
+
+Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
+    Ptr<IStreamingReporter> resultingReporter;
+
+    if( existingReporter ) {
+        MultipleReporters* multi = existingReporter->tryAsMulti();
+        if( !multi ) {
+            multi = new MultipleReporters;
+            resultingReporter = Ptr<IStreamingReporter>( multi );
+            if( existingReporter )
+                multi->add( existingReporter );
+        }
+        else
+            resultingReporter = existingReporter;
+        multi->add( additionalReporter );
+    }
+    else
+        resultingReporter = additionalReporter;
+
+    return resultingReporter;
+}
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_xml.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
+
+// #included from: catch_reporter_bases.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
+
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <assert.h>
+
+namespace Catch {
+
+    namespace {
+        // Because formatting using c++ streams is stateful, drop down to C is required
+        // Alternatively we could use stringstream, but its performance is... not good.
+        std::string getFormattedDuration( double duration ) {
+            // Max exponent + 1 is required to represent the whole part
+            // + 1 for decimal point
+            // + 3 for the 3 decimal places
+            // + 1 for null terminator
+            const size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+            char buffer[maxDoubleSize];
+
+            // Save previous errno, to prevent sprintf from overwriting it
+            ErrnoGuard guard;
+#ifdef _MSC_VER
+            sprintf_s(buffer, "%.3f", duration);
+#else
+            sprintf(buffer, "%.3f", duration);
+#endif
+            return std::string(buffer);
+        }
+    }
+
+    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+        }
+
+        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
+            return m_reporterPrefs;
+        }
+
+        virtual ~StreamingReporterBase() CATCH_OVERRIDE;
+
+        virtual void noMatchingTestCases( std::string const& ) CATCH_OVERRIDE {}
+
+        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) CATCH_OVERRIDE {
+            currentTestRunInfo = _testRunInfo;
+        }
+        virtual void testGroupStarting( GroupInfo const& _groupInfo ) CATCH_OVERRIDE {
+            currentGroupInfo = _groupInfo;
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) CATCH_OVERRIDE {
+            currentTestCaseInfo = _testInfo;
+        }
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
+            m_sectionStack.push_back( _sectionInfo );
+        }
+
+        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) CATCH_OVERRIDE {
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) CATCH_OVERRIDE {
+            currentTestCaseInfo.reset();
+        }
+        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) CATCH_OVERRIDE {
+            currentGroupInfo.reset();
+        }
+        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) CATCH_OVERRIDE {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        Ptr<IConfig const> m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
+        template<typename T, typename ChildNodeT>
+        struct Node : SharedImpl<> {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            typedef std::vector<Ptr<ChildNodeT> > ChildNodes;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode : SharedImpl<> {
+            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
+            virtual ~SectionNode();
+
+            bool operator == ( SectionNode const& other ) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == ( Ptr<SectionNode> const& other ) const {
+                return operator==( *other );
+            }
+
+            SectionStats stats;
+            typedef std::vector<Ptr<SectionNode> > ChildSections;
+            typedef std::vector<AssertionStats> Assertions;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() ( Ptr<SectionNode> const& node ) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+        private:
+            void operator=( BySectionInfo const& );
+            SectionInfo const& m_other;
+        };
+
+        typedef Node<TestCaseStats, SectionNode> TestCaseNode;
+        typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
+        typedef Node<TestRunStats, TestGroupNode> TestRunNode;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+        }
+        ~CumulativeReporterBase();
+
+        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
+            return m_reporterPrefs;
+        }
+
+        virtual void testRunStarting( TestRunInfo const& ) CATCH_OVERRIDE {}
+        virtual void testGroupStarting( GroupInfo const& ) CATCH_OVERRIDE {}
+
+        virtual void testCaseStarting( TestCaseInfo const& ) CATCH_OVERRIDE {}
+
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            Ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = new SectionNode( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                SectionNode::ChildSections::const_iterator it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = new SectionNode( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = node;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+            assert( !m_sectionStack.empty() );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back( assertionStats );
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression( sectionNode.assertions.back().assertionResult );
+            return true;
+        }
+        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
+            assert( !m_sectionStack.empty() );
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
+            assert( m_sectionStack.size() == 0 );
+            node->children.push_back( m_rootSection );
+            m_testCases.push_back( node );
+            m_rootSection.reset();
+
+            assert( m_deepestSection );
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+            Ptr<TestGroupNode> node = new TestGroupNode( testGroupStats );
+            node->children.swap( m_testCases );
+            m_testGroups.push_back( node );
+        }
+        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
+            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
+            node->children.swap( m_testGroups );
+            m_testRuns.push_back( node );
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {}
+
+        virtual void prepareExpandedExpression( AssertionResult& result ) const {
+            if( result.isOk() )
+                result.discardDecomposedExpression();
+            else
+                result.expandDecomposedExpression();
+        }
+
+        Ptr<IConfig const> m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<Ptr<SectionNode> > > m_sections;
+        std::vector<Ptr<TestCaseNode> > m_testCases;
+        std::vector<Ptr<TestGroupNode> > m_testGroups;
+
+        std::vector<Ptr<TestRunNode> > m_testRuns;
+
+        Ptr<SectionNode> m_rootSection;
+        Ptr<SectionNode> m_deepestSection;
+        std::vector<Ptr<SectionNode> > m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase {
+        TestEventListenerBase( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config )
+        {}
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
+        virtual bool assertionEnded( AssertionStats const& ) CATCH_OVERRIDE {
+            return false;
+        }
+    };
+
+} // end namespace Catch
+
+// #included from: ../internal/catch_reporter_registrars.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+namespace Catch {
+
+    template<typename T>
+    class LegacyReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new LegacyReporterAdapter( new T( config ) );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        LegacyReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public SharedImpl<IReporterFactory> {
+
+            // *** Please Note ***:
+            // - If you end up here looking at a compiler error because it's trying to register
+            // your custom reporter class be aware that the native reporter interface has changed
+            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
+            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
+            // However please consider updating to the new interface as the old one is now
+            // deprecated and will probably be removed quite soon!
+            // Please contact me via github if you have any questions at all about this.
+            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
+            // no idea who is actually using custom reporters at all (possibly no-one!).
+            // The new interface is designed to minimise exposure to interface changes in the future.
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new T( config );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+
+    template<typename T>
+    class ListenerRegistrar {
+
+        class ListenerFactory : public SharedImpl<IReporterFactory> {
+
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new T( config );
+            }
+            virtual std::string getDescription() const {
+                return std::string();
+            }
+        };
+
+    public:
+
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( new ListenerFactory() );
+        }
+    };
+}
+
+#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
+    namespace{ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+
+#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+
+// Deprecated - use the form without INTERNAL_
+#define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+
+// #included from: ../internal/catch_xmlwriter.hpp
+#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
+
+#include <sstream>
+#include <string>
+#include <vector>
+#include <iomanip>
+
+namespace Catch {
+
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes )
+        :   m_str( str ),
+            m_forWhat( forWhat )
+        {}
+
+        void encodeTo( std::ostream& os ) const {
+
+            // Apostrophe escaping not necessary if we always use " to write attributes
+            // (see: http://www.w3.org/TR/xml/#syntax)
+
+            for( std::size_t i = 0; i < m_str.size(); ++ i ) {
+                char c = m_str[i];
+                switch( c ) {
+                    case '<':   os << "&lt;"; break;
+                    case '&':   os << "&amp;"; break;
+
+                    case '>':
+                        // See: http://www.w3.org/TR/xml/#syntax
+                        if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' )
+                            os << "&gt;";
+                        else
+                            os << c;
+                        break;
+
+                    case '\"':
+                        if( m_forWhat == ForAttributes )
+                            os << "&quot;";
+                        else
+                            os << c;
+                        break;
+
+                    default:
+                        // Escape control chars - based on contribution by @espenalb in PR #465 and
+                        // by @mrpi PR #588
+                        if ( ( c >= 0 && c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) {
+                            // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                            os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+                               << static_cast<int>( c );
+                        }
+                        else
+                            os << c;
+                }
+            }
+        }
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+            xmlEncode.encodeTo( os );
+            return os;
+        }
+
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer )
+            :   m_writer( writer )
+            {}
+
+            ScopedElement( ScopedElement const& other )
+            :   m_writer( other.m_writer ){
+                other.m_writer = CATCH_NULL;
+            }
+
+            ~ScopedElement() {
+                if( m_writer )
+                    m_writer->endElement();
+            }
+
+            ScopedElement& writeText( std::string const& text, bool indent = true ) {
+                m_writer->writeText( text, indent );
+                return *this;
+            }
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer;
+        };
+
+        XmlWriter()
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( Catch::cout() )
+        {
+            writeDeclaration();
+        }
+
+        XmlWriter( std::ostream& os )
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( os )
+        {
+            writeDeclaration();
+        }
+
+        ~XmlWriter() {
+            while( !m_tags.empty() )
+                endElement();
+        }
+
+        XmlWriter& startElement( std::string const& name ) {
+            ensureTagClosed();
+            newlineIfNecessary();
+            m_os << m_indent << '<' << name;
+            m_tags.push_back( name );
+            m_indent += "  ";
+            m_tagIsOpen = true;
+            return *this;
+        }
+
+        ScopedElement scopedElement( std::string const& name ) {
+            ScopedElement scoped( this );
+            startElement( name );
+            return scoped;
+        }
+
+        XmlWriter& endElement() {
+            newlineIfNecessary();
+            m_indent = m_indent.substr( 0, m_indent.size()-2 );
+            if( m_tagIsOpen ) {
+                m_os << "/>";
+                m_tagIsOpen = false;
+            }
+            else {
+                m_os << m_indent << "</" << m_tags.back() << ">";
+            }
+            m_os << std::endl;
+            m_tags.pop_back();
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
+            if( !name.empty() && !attribute.empty() )
+                m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
+            m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+            return *this;
+        }
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            std::ostringstream oss;
+            oss << attribute;
+            return writeAttribute( name, oss.str() );
+        }
+
+        XmlWriter& writeText( std::string const& text, bool indent = true ) {
+            if( !text.empty() ){
+                bool tagWasOpen = m_tagIsOpen;
+                ensureTagClosed();
+                if( tagWasOpen && indent )
+                    m_os << m_indent;
+                m_os << XmlEncode( text );
+                m_needsNewline = true;
+            }
+            return *this;
+        }
+
+        XmlWriter& writeComment( std::string const& text ) {
+            ensureTagClosed();
+            m_os << m_indent << "<!--" << text << "-->";
+            m_needsNewline = true;
+            return *this;
+        }
+
+        void writeStylesheetRef( std::string const& url ) {
+            m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+        }
+
+        XmlWriter& writeBlankLine() {
+            ensureTagClosed();
+            m_os << '\n';
+            return *this;
+        }
+
+        void ensureTagClosed() {
+            if( m_tagIsOpen ) {
+                m_os << ">" << std::endl;
+                m_tagIsOpen = false;
+            }
+        }
+
+    private:
+        XmlWriter( XmlWriter const& );
+        void operator=( XmlWriter const& );
+
+        void writeDeclaration() {
+            m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+        }
+
+        void newlineIfNecessary() {
+            if( m_needsNewline ) {
+                m_os << std::endl;
+                m_needsNewline = false;
+            }
+        }
+
+        bool m_tagIsOpen;
+        bool m_needsNewline;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase {
+    public:
+        XmlReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_xml(_config.stream()),
+            m_sectionDepth( 0 )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        virtual ~XmlReporter() CATCH_OVERRIDE;
+
+        static std::string getDescription() {
+            return "Reports test results as an XML document";
+        }
+
+        virtual std::string getStylesheetRef() const {
+            return std::string();
+        }
+
+        void writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+            m_xml
+                .writeAttribute( "filename", sourceInfo.file )
+                .writeAttribute( "line", sourceInfo.line );
+        }
+
+    public: // StreamingReporterBase
+
+        virtual void noMatchingTestCases( std::string const& s ) CATCH_OVERRIDE {
+            StreamingReporterBase::noMatchingTestCases( s );
+        }
+
+        virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::testRunStarting( testInfo );
+            std::string stylesheetRef = getStylesheetRef();
+            if( !stylesheetRef.empty() )
+                m_xml.writeStylesheetRef( stylesheetRef );
+            m_xml.startElement( "Catch" );
+            if( !m_config->name().empty() )
+                m_xml.writeAttribute( "name", m_config->name() );
+        }
+
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            m_xml.startElement( "Group" )
+                .writeAttribute( "name", groupInfo.name );
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::testCaseStarting(testInfo);
+            m_xml.startElement( "TestCase" )
+                .writeAttribute( "name", trim( testInfo.name ) )
+                .writeAttribute( "description", testInfo.description )
+                .writeAttribute( "tags", testInfo.tagsAsString );
+
+            writeSourceInfo( testInfo.lineInfo );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                m_testCaseTimer.start();
+            m_xml.ensureTagClosed();
+        }
+
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
+            StreamingReporterBase::sectionStarting( sectionInfo );
+            if( m_sectionDepth++ > 0 ) {
+                m_xml.startElement( "Section" )
+                    .writeAttribute( "name", trim( sectionInfo.name ) )
+                    .writeAttribute( "description", sectionInfo.description );
+                writeSourceInfo( sectionInfo.lineInfo );
+                m_xml.ensureTagClosed();
+            }
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { }
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+
+            AssertionResult const& result = assertionStats.assertionResult;
+
+            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+            if( includeResults || result.getResultType() == ResultWas::Warning ) {
+                // Print any info messages in <Info> tags.
+                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                     it != itEnd;
+                     ++it ) {
+                    if( it->type == ResultWas::Info && includeResults ) {
+                        m_xml.scopedElement( "Info" )
+                                .writeText( it->message );
+                    } else if ( it->type == ResultWas::Warning ) {
+                        m_xml.scopedElement( "Warning" )
+                                .writeText( it->message );
+                    }
+                }
+            }
+
+            // Drop out if result was successful but we're not printing them.
+            if( !includeResults && result.getResultType() != ResultWas::Warning )
+                return true;
+
+            // Print the expression if there is one.
+            if( result.hasExpression() ) {
+                m_xml.startElement( "Expression" )
+                    .writeAttribute( "success", result.succeeded() )
+                    .writeAttribute( "type", result.getTestMacroName() );
+
+                writeSourceInfo( result.getSourceInfo() );
+
+                m_xml.scopedElement( "Original" )
+                    .writeText( result.getExpression() );
+                m_xml.scopedElement( "Expanded" )
+                    .writeText( result.getExpandedExpression() );
+            }
+
+            // And... Print a result applicable to each result type.
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                    m_xml.startElement( "Exception" );
+                    writeSourceInfo( result.getSourceInfo() );
+                    m_xml.writeText( result.getMessage() );
+                    m_xml.endElement();
+                    break;
+                case ResultWas::FatalErrorCondition:
+                    m_xml.startElement( "FatalErrorCondition" );
+                    writeSourceInfo( result.getSourceInfo() );
+                    m_xml.writeText( result.getMessage() );
+                    m_xml.endElement();
+                    break;
+                case ResultWas::Info:
+                    m_xml.scopedElement( "Info" )
+                        .writeText( result.getMessage() );
+                    break;
+                case ResultWas::Warning:
+                    // Warning will already have been written
+                    break;
+                case ResultWas::ExplicitFailure:
+                    m_xml.startElement( "Failure" );
+                    writeSourceInfo( result.getSourceInfo() );
+                    m_xml.writeText( result.getMessage() );
+                    m_xml.endElement();
+                    break;
+                default:
+                    break;
+            }
+
+            if( result.hasExpression() )
+                m_xml.endElement();
+
+            return true;
+        }
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::sectionEnded( sectionStats );
+            if( --m_sectionDepth > 0 ) {
+                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+                e.writeAttribute( "successes", sectionStats.assertions.passed );
+                e.writeAttribute( "failures", sectionStats.assertions.failed );
+                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+                if ( m_config->showDurations() == ShowDurations::Always )
+                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+                m_xml.endElement();
+            }
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+            if( !testCaseStats.stdOut.empty() )
+                m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
+            if( !testCaseStats.stdErr.empty() )
+                m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
+
+            m_xml.endElement();
+        }
+
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            // TODO: Check testGroupStats.aborting and act accordingly.
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testRunEnded( testRunStats );
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth;
+    };
+
+     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_junit.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+#include <assert.h>
+
+namespace Catch {
+
+    namespace {
+        std::string getCurrentTimestamp() {
+            // Beware, this is not reentrant because of backward compatibility issues
+            // Also, UTC only, again because of backward compatibility (%z is C++11)
+            time_t rawtime;
+            std::time(&rawtime);
+            const size_t timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            std::tm* timeInfo;
+            timeInfo = std::gmtime(&rawtime);
+#endif
+
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+
+    }
+
+    class JunitReporter : public CumulativeReporterBase {
+    public:
+        JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() ),
+            unexpectedExceptions( 0 ),
+            m_okToFail( false )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        virtual ~JunitReporter() CATCH_OVERRIDE;
+
+        static std::string getDescription() {
+            return "Reports test results in an XML format that looks like Ant's junitreport target";
+        }
+
+        virtual void noMatchingTestCases( std::string const& /*spec*/ ) CATCH_OVERRIDE {}
+
+        virtual void testRunStarting( TestRunInfo const& runInfo ) CATCH_OVERRIDE {
+            CumulativeReporterBase::testRunStarting( runInfo );
+            xml.startElement( "testsuites" );
+        }
+
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
+            suiteTimer.start();
+            stdOutForSuite.str("");
+            stdErrForSuite.str("");
+            unexpectedExceptions = 0;
+            CumulativeReporterBase::testGroupStarting( groupInfo );
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& testCaseInfo ) CATCH_OVERRIDE {
+            m_okToFail = testCaseInfo.okToFail();
+        }
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
+            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+                unexpectedExceptions++;
+            return CumulativeReporterBase::assertionEnded( assertionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
+            stdOutForSuite << testCaseStats.stdOut;
+            stdErrForSuite << testCaseStats.stdErr;
+            CumulativeReporterBase::testCaseEnded( testCaseStats );
+        }
+
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
+            double suiteTime = suiteTimer.getElapsedSeconds();
+            CumulativeReporterBase::testGroupEnded( testGroupStats );
+            writeGroup( *m_testGroups.back(), suiteTime );
+        }
+
+        virtual void testRunEndedCumulative() CATCH_OVERRIDE {
+            xml.endElement();
+        }
+
+        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+            TestGroupStats const& stats = groupNode.value;
+            xml.writeAttribute( "name", stats.groupInfo.name );
+            xml.writeAttribute( "errors", unexpectedExceptions );
+            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+            xml.writeAttribute( "tests", stats.totals.assertions.total() );
+            xml.writeAttribute( "hostname", "tbd" ); // !TBD
+            if( m_config->showDurations() == ShowDurations::Never )
+                xml.writeAttribute( "time", "" );
+            else
+                xml.writeAttribute( "time", suiteTime );
+            xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+            // Write test cases
+            for( TestGroupNode::ChildNodes::const_iterator
+                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
+                    it != itEnd;
+                    ++it )
+                writeTestCase( **it );
+
+            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
+            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
+        }
+
+        void writeTestCase( TestCaseNode const& testCaseNode ) {
+            TestCaseStats const& stats = testCaseNode.value;
+
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert( testCaseNode.children.size() == 1 );
+            SectionNode const& rootSection = *testCaseNode.children.front();
+
+            std::string className = stats.testInfo.className;
+
+            if( className.empty() ) {
+                if( rootSection.childSections.empty() )
+                    className = "global";
+            }
+            writeSection( className, "", rootSection );
+        }
+
+        void writeSection(  std::string const& className,
+                            std::string const& rootName,
+                            SectionNode const& sectionNode ) {
+            std::string name = trim( sectionNode.stats.sectionInfo.name );
+            if( !rootName.empty() )
+                name = rootName + '/' + name;
+
+            if( !sectionNode.assertions.empty() ||
+                !sectionNode.stdOut.empty() ||
+                !sectionNode.stdErr.empty() ) {
+                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+                if( className.empty() ) {
+                    xml.writeAttribute( "classname", name );
+                    xml.writeAttribute( "name", "root" );
+                }
+                else {
+                    xml.writeAttribute( "classname", className );
+                    xml.writeAttribute( "name", name );
+                }
+                xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );
+
+                writeAssertions( sectionNode );
+
+                if( !sectionNode.stdOut.empty() )
+                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
+                if( !sectionNode.stdErr.empty() )
+                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
+            }
+            for( SectionNode::ChildSections::const_iterator
+                    it = sectionNode.childSections.begin(),
+                    itEnd = sectionNode.childSections.end();
+                    it != itEnd;
+                    ++it )
+                if( className.empty() )
+                    writeSection( name, "", **it );
+                else
+                    writeSection( className, name, **it );
+        }
+
+        void writeAssertions( SectionNode const& sectionNode ) {
+            for( SectionNode::Assertions::const_iterator
+                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
+                    it != itEnd;
+                    ++it )
+                writeAssertion( *it );
+        }
+        void writeAssertion( AssertionStats const& stats ) {
+            AssertionResult const& result = stats.assertionResult;
+            if( !result.isOk() ) {
+                std::string elementName;
+                switch( result.getResultType() ) {
+                    case ResultWas::ThrewException:
+                    case ResultWas::FatalErrorCondition:
+                        elementName = "error";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        elementName = "failure";
+                        break;
+
+                    // We should never see these here:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                    case ResultWas::Ok:
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        elementName = "internalError";
+                        break;
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+                xml.writeAttribute( "message", result.getExpandedExpression() );
+                xml.writeAttribute( "type", result.getTestMacroName() );
+
+                std::ostringstream oss;
+                if( !result.getMessage().empty() )
+                    oss << result.getMessage() << '\n';
+                for( std::vector<MessageInfo>::const_iterator
+                        it = stats.infoMessages.begin(),
+                        itEnd = stats.infoMessages.end();
+                            it != itEnd;
+                            ++it )
+                    if( it->type == ResultWas::Info )
+                        oss << it->message << '\n';
+
+                oss << "at " << result.getSourceInfo();
+                xml.writeText( oss.str(), false );
+            }
+        }
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::ostringstream stdOutForSuite;
+        std::ostringstream stdErrForSuite;
+        unsigned int unexpectedExceptions;
+        bool m_okToFail;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_console.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+#include <cfloat>
+#include <cstdio>
+
+namespace Catch {
+
+    struct ConsoleReporter : StreamingReporterBase {
+        ConsoleReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_headerPrinted( false )
+        {}
+
+        virtual ~ConsoleReporter() CATCH_OVERRIDE;
+        static std::string getDescription() {
+            return "Reports test results as plain lines of text";
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+            // Drop out if result was successful but we're not printing them.
+            if( !includeResults && result.getResultType() != ResultWas::Warning )
+                return false;
+
+            lazyPrint();
+
+            AssertionPrinter printer( stream, _assertionStats, includeResults );
+            printer.print();
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionStarting( _sectionInfo );
+        }
+        virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE {
+            if( _sectionStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                if( m_sectionStack.size() > 1 )
+                    stream << "\nNo assertions in section";
+                else
+                    stream << "\nNo assertions in test case";
+                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+            }
+            if( m_config->showDurations() == ShowDurations::Always ) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+            if( m_headerPrinted ) {
+                m_headerPrinted = false;
+            }
+            StreamingReporterBase::sectionEnded( _sectionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) CATCH_OVERRIDE {
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+            m_headerPrinted = false;
+        }
+        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
+            if( currentGroupInfo.used ) {
+                printSummaryDivider();
+                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+                printTotals( _testGroupStats.totals );
+                stream << '\n' << std::endl;
+            }
+            StreamingReporterBase::testGroupEnded( _testGroupStats );
+        }
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
+            printTotalsDivider( _testRunStats.totals );
+            printTotals( _testRunStats.totals );
+            stream << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            :   stream( _stream ),
+                stats( _stats ),
+                result( _stats.assertionResult ),
+                colour( Colour::None ),
+                message( result.getMessage() ),
+                messages( _stats.infoMessages ),
+                printInfoMessages( _printInfoMessages )
+            {
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        colour = Colour::Success;
+                        passOrFail = "PASSED";
+                        //if( result.hasMessage() )
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() ) {
+                            colour = Colour::Success;
+                            passOrFail = "FAILED - but was ok";
+                        }
+                        else {
+                            colour = Colour::Error;
+                            passOrFail = "FAILED";
+                        }
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ThrewException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to unexpected exception with ";
+                        if (_stats.infoMessages.size() == 1)
+                            messageLabel += "message";
+                        if (_stats.infoMessages.size() > 1)
+                            messageLabel += "messages";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to a fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "because no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::Info:
+                        messageLabel = "info";
+                        break;
+                    case ResultWas::Warning:
+                        messageLabel = "warning";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        passOrFail = "FAILED";
+                        colour = Colour::Error;
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "explicitly with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "explicitly with messages";
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        passOrFail = "** internal error **";
+                        colour = Colour::Error;
+                        break;
+                }
+            }
+
+            void print() const {
+                printSourceInfo();
+                if( stats.totals.assertions.total() > 0 ) {
+                    if( result.isOk() )
+                        stream << '\n';
+                    printResultType();
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                }
+                else {
+                    stream << '\n';
+                }
+                printMessage();
+            }
+
+        private:
+            void printResultType() const {
+                if( !passOrFail.empty() ) {
+                    Colour colourGuard( colour );
+                    stream << passOrFail << ":\n";
+                }
+            }
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    Colour colourGuard( Colour::OriginalExpression );
+                    stream  << "  ";
+                    stream << result.getExpressionInMacro();
+                    stream << '\n';
+                }
+            }
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    stream << "with expansion:\n";
+                    Colour colourGuard( Colour::ReconstructedExpression );
+                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << '\n';
+                }
+            }
+            void printMessage() const {
+                if( !messageLabel.empty() )
+                    stream << messageLabel << ':' << '\n';
+                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+                        it != itEnd;
+                        ++it ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || it->type != ResultWas::Info )
+                        stream << Text( it->message, TextAttributes().setIndent(2) ) << '\n';
+                }
+            }
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ": ";
+            }
+
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            Colour::Code colour;
+            std::string passOrFail;
+            std::string messageLabel;
+            std::string message;
+            std::vector<MessageInfo> messages;
+            bool printInfoMessages;
+        };
+
+        void lazyPrint() {
+
+            if( !currentTestRunInfo.used )
+                lazyPrintRunInfo();
+            if( !currentGroupInfo.used )
+                lazyPrintGroupInfo();
+
+            if( !m_headerPrinted ) {
+                printTestCaseAndSectionHeader();
+                m_headerPrinted = true;
+            }
+        }
+        void lazyPrintRunInfo() {
+            stream  << '\n' << getLineOfChars<'~'>() << '\n';
+            Colour colour( Colour::SecondaryText );
+            stream  << currentTestRunInfo->name
+                    << " is a Catch v"  << libraryVersion() << " host application.\n"
+                    << "Run with -? for options\n\n";
+
+            if( m_config->rngSeed() != 0 )
+                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+            currentTestRunInfo.used = true;
+        }
+        void lazyPrintGroupInfo() {
+            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
+                printClosedHeader( "Group: " + currentGroupInfo->name );
+                currentGroupInfo.used = true;
+            }
+        }
+        void printTestCaseAndSectionHeader() {
+            assert( !m_sectionStack.empty() );
+            printOpenHeader( currentTestCaseInfo->name );
+
+            if( m_sectionStack.size() > 1 ) {
+                Colour colourGuard( Colour::Headers );
+
+                std::vector<SectionInfo>::const_iterator
+                    it = m_sectionStack.begin()+1, // Skip first section (test case)
+                    itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( it->name, 2 );
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+            if( !lineInfo.empty() ){
+                stream << getLineOfChars<'-'>() << '\n';
+                Colour colourGuard( Colour::FileName );
+                stream << lineInfo << '\n';
+            }
+            stream << getLineOfChars<'.'>() << '\n' << std::endl;
+        }
+
+        void printClosedHeader( std::string const& _name ) {
+            printOpenHeader( _name );
+            stream << getLineOfChars<'.'>() << '\n';
+        }
+        void printOpenHeader( std::string const& _name ) {
+            stream  << getLineOfChars<'-'>() << '\n';
+            {
+                Colour colourGuard( Colour::Headers );
+                printHeaderString( _name );
+            }
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            stream << Text( _string, TextAttributes()
+                                        .setIndent( indent+i)
+                                        .setInitialIndent( indent ) ) << '\n';
+        }
+
+        struct SummaryColumn {
+
+            SummaryColumn( std::string const& _label, Colour::Code _colour )
+            :   label( _label ),
+                colour( _colour )
+            {}
+            SummaryColumn addRow( std::size_t count ) {
+                std::ostringstream oss;
+                oss << count;
+                std::string row = oss.str();
+                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
+                    while( it->size() < row.size() )
+                        *it = ' ' + *it;
+                    while( it->size() > row.size() )
+                        row = ' ' + row;
+                }
+                rows.push_back( row );
+                return *this;
+            }
+
+            std::string label;
+            Colour::Code colour;
+            std::vector<std::string> rows;
+
+        };
+
+        void printTotals( Totals const& totals ) {
+            if( totals.testCases.total() == 0 ) {
+                stream << Colour( Colour::Warning ) << "No tests ran\n";
+            }
+            else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
+                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
+                stream << " ("
+                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
+                        << pluralise( totals.testCases.passed, "test case" ) << ')'
+                        << '\n';
+            }
+            else {
+
+                std::vector<SummaryColumn> columns;
+                columns.push_back( SummaryColumn( "", Colour::None )
+                                        .addRow( totals.testCases.total() )
+                                        .addRow( totals.assertions.total() ) );
+                columns.push_back( SummaryColumn( "passed", Colour::Success )
+                                        .addRow( totals.testCases.passed )
+                                        .addRow( totals.assertions.passed ) );
+                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+                                        .addRow( totals.testCases.failed )
+                                        .addRow( totals.assertions.failed ) );
+                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+                                        .addRow( totals.testCases.failedButOk )
+                                        .addRow( totals.assertions.failedButOk ) );
+
+                printSummaryRow( "test cases", columns, 0 );
+                printSummaryRow( "assertions", columns, 1 );
+            }
+        }
+        void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
+            for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
+                std::string value = it->rows[row];
+                if( it->label.empty() ) {
+                    stream << label << ": ";
+                    if( value != "0" )
+                        stream << value;
+                    else
+                        stream << Colour( Colour::Warning ) << "- none -";
+                }
+                else if( value != "0" ) {
+                    stream  << Colour( Colour::LightGrey ) << " | ";
+                    stream  << Colour( it->colour )
+                            << value << ' ' << it->label;
+                }
+            }
+            stream << '\n';
+        }
+
+        static std::size_t makeRatio( std::size_t number, std::size_t total ) {
+            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
+            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
+        }
+        static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
+            if( i > j && i > k )
+                return i;
+            else if( j > k )
+                return j;
+            else
+                return k;
+        }
+
+        void printTotalsDivider( Totals const& totals ) {
+            if( totals.testCases.total() > 0 ) {
+                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
+                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
+                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
+                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
+                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )--;
+
+                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
+                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
+                if( totals.testCases.allPassed() )
+                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
+                else
+                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
+            }
+            else {
+                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
+            }
+            stream << '\n';
+        }
+        void printSummaryDivider() {
+            stream << getLineOfChars<'-'>() << '\n';
+        }
+
+    private:
+        bool m_headerPrinted;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_compact.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase {
+
+        CompactReporter( ReporterConfig const& _config )
+        : StreamingReporterBase( _config )
+        {}
+
+        virtual ~CompactReporter();
+
+        static std::string getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << '\'' << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {}
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void sectionEnded(SectionStats const& _sectionStats) CATCH_OVERRIDE {
+            if (m_config->showDurations() == ShowDurations::Always) {
+                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            }
+        }
+
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( _testRunStats.totals );
+            stream << '\n' << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            : stream( _stream )
+            , stats( _stats )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( _printInfoMessages )
+            {}
+
+            void print() {
+                printSourceInfo();
+
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( Colour::ResultSuccess, passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() )
+                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
+                        else
+                            printResultType( Colour::Error, failedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( Colour::None, "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( Colour::None, "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( Colour::Error, "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            // Colour::LightGrey
+
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+#ifdef CATCH_PLATFORM_MAC
+            static const char* failedString() { return "FAILED"; }
+            static const char* passedString() { return "PASSED"; }
+#else
+            static const char* failedString() { return "failed"; }
+            static const char* passedString() { return "passed"; }
+#endif
+
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ':';
+            }
+
+            void printResultType( Colour::Code colour, std::string const& passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    {
+                        Colour colourGuard( colour );
+                        stream << ' ' << passOrFail;
+                    }
+                    stream << ':';
+                }
+            }
+
+            void printIssue( std::string const& issue ) const {
+                stream << ' ' << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ';';
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << ' ' << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    stream << result.getExpandedExpression();
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << '\'';
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if ( itMessage == messages.end() )
+                    return;
+
+                // using messages.end() directly yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ':';
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << '\'';
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+        };
+
+        // Colour, message variants:
+        // - white: No tests ran.
+        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+        // - white: Passed [both/all] N test cases (no assertions).
+        // -   red: Failed N tests cases, failed M assertions.
+        // - green: Passed [both/all] N tests cases with M assertions.
+
+        std::string bothOrAll( std::size_t count ) const {
+            return count == 1 ? std::string() : count == 2 ? "both " : "all " ;
+        }
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "No tests ran.";
+            }
+            else if( totals.testCases.failed == totals.testCases.total() ) {
+                Colour colour( Colour::ResultError );
+                const std::string qualify_assertions_failed =
+                    totals.assertions.failed == totals.assertions.total() ?
+                        bothOrAll( totals.assertions.failed ) : std::string();
+                stream <<
+                    "Failed " << bothOrAll( totals.testCases.failed )
+                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << qualify_assertions_failed <<
+                                 pluralise( totals.assertions.failed, "assertion" ) << '.';
+            }
+            else if( totals.assertions.total() == 0 ) {
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.total() )
+                              << pluralise( totals.testCases.total(), "test case" )
+                              << " (no assertions).";
+            }
+            else if( totals.assertions.failed ) {
+                Colour colour( Colour::ResultError );
+                stream <<
+                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << '.';
+            }
+            else {
+                Colour colour( Colour::ResultSuccess );
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.passed )
+                              << pluralise( totals.testCases.passed, "test case"  ) <<
+                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << '.';
+            }
+        }
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+
+namespace Catch {
+    // These are all here to avoid warnings about not having any out of line
+    // virtual methods
+    NonCopyable::~NonCopyable() {}
+    IShared::~IShared() {}
+    IStream::~IStream() CATCH_NOEXCEPT {}
+    FileStream::~FileStream() CATCH_NOEXCEPT {}
+    CoutStream::~CoutStream() CATCH_NOEXCEPT {}
+    DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {}
+    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
+    IContext::~IContext() {}
+    IResultCapture::~IResultCapture() {}
+    ITestCase::~ITestCase() {}
+    ITestCaseRegistry::~ITestCaseRegistry() {}
+    IRegistryHub::~IRegistryHub() {}
+    IMutableRegistryHub::~IMutableRegistryHub() {}
+    IExceptionTranslator::~IExceptionTranslator() {}
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
+    IReporter::~IReporter() {}
+    IReporterFactory::~IReporterFactory() {}
+    IReporterRegistry::~IReporterRegistry() {}
+    IStreamingReporter::~IStreamingReporter() {}
+    AssertionStats::~AssertionStats() {}
+    SectionStats::~SectionStats() {}
+    TestCaseStats::~TestCaseStats() {}
+    TestGroupStats::~TestGroupStats() {}
+    TestRunStats::~TestRunStats() {}
+    CumulativeReporterBase::SectionNode::~SectionNode() {}
+    CumulativeReporterBase::~CumulativeReporterBase() {}
+
+    StreamingReporterBase::~StreamingReporterBase() {}
+    ConsoleReporter::~ConsoleReporter() {}
+    CompactReporter::~CompactReporter() {}
+    IRunner::~IRunner() {}
+    IMutableContext::~IMutableContext() {}
+    IConfig::~IConfig() {}
+    XmlReporter::~XmlReporter() {}
+    JunitReporter::~JunitReporter() {}
+    TestRegistry::~TestRegistry() {}
+    FreeFunctionTestCase::~FreeFunctionTestCase() {}
+    IGeneratorInfo::~IGeneratorInfo() {}
+    IGeneratorsForTest::~IGeneratorsForTest() {}
+    WildcardPattern::~WildcardPattern() {}
+    TestSpec::Pattern::~Pattern() {}
+    TestSpec::NamePattern::~NamePattern() {}
+    TestSpec::TagPattern::~TagPattern() {}
+    TestSpec::ExcludedPattern::~ExcludedPattern() {}
+    Matchers::Impl::MatcherUntypedBase::~MatcherUntypedBase() {}
+
+    void Config::dummy() {}
+
+    namespace TestCaseTracking {
+        ITracker::~ITracker() {}
+        TrackerBase::~TrackerBase() {}
+        SectionTracker::~SectionTracker() {}
+        IndexTracker::~IndexTracker() {}
+    }
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// #included from: internal/catch_default_main.hpp
+#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
+
+#ifndef __OBJC__
+
+#if defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+    int result = Catch::Session().run( argc, argv );
+    return ( result < 0xff ? result : 0xff );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char* const*)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return ( result < 0xff ? result : 0xff );
+}
+
+#endif // __OBJC__
+
+#endif
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+//////
+
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#else
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr  )
+#endif
+
+#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
+
+#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
+
+#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
+
+#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
+#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+    #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#else
+    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description )
+    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
+#endif
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
+#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define CATCH_GIVEN( desc )    CATCH_SECTION( std::string( "Given: ") + desc, "" )
+#define CATCH_WHEN( desc )     CATCH_SECTION( std::string( " When: ") + desc, "" )
+#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
+#define CATCH_THEN( desc )     CATCH_SECTION( std::string( " Then: ") + desc, "" )
+#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+
+#else
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, expr  )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#endif
+
+#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
+
+#define CHECK( expr ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
+#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
+
+#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
+
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+
+#if defined(CATCH_CONFIG_FAST_COMPILE)
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#else
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+#endif
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
+#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#else
+#define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description )
+    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define FAIL( msg ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
+    #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
+    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
+#endif
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
+#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define GIVEN( desc )    SECTION( std::string("   Given: ") + desc, "" )
+#define WHEN( desc )     SECTION( std::string("    When: ") + desc, "" )
+#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" )
+#define THEN( desc )     SECTION( std::string("    Then: ") + desc, "" )
+#define AND_THEN( desc ) SECTION( std::string("     And: ") + desc, "" )
+
+using Catch::Detail::Approx;
+
+// #included from: internal/catch_reenable_warnings.h
+
+#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#    ifdef __ICC // icpc defines the __clang__ macro
+#        pragma warning(pop)
+#    else
+#        pragma clang diagnostic pop
+#    endif
+#elif defined __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/third_party/vtzero/test/data/mapbox-streets-v6-14-8714-8017.mvt b/third_party/vtzero/test/data/mapbox-streets-v6-14-8714-8017.mvt
new file mode 100644
index 00000000000..a50140a25be
Binary files /dev/null and b/third_party/vtzero/test/data/mapbox-streets-v6-14-8714-8017.mvt differ
diff --git a/third_party/vtzero/test/fixture_tests.cpp b/third_party/vtzero/test/fixture_tests.cpp
new file mode 100644
index 00000000000..aca383d1dc9
--- /dev/null
+++ b/third_party/vtzero/test/fixture_tests.cpp
@@ -0,0 +1,1003 @@
+
+#include <test.hpp>
+
+#include <vtzero/builder.hpp>
+#include <vtzero/geometry.hpp>
+#include <vtzero/vector_tile.hpp>
+
+#include <cstdint>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+static std::string open_tile(const std::string& path) {
+    const auto fixtures_dir = std::getenv("FIXTURES_DIR");
+    if (fixtures_dir == nullptr) {
+        std::cerr << "Set FIXTURES_DIR environment variable to the directory where the mvt fixtures are!\n";
+        std::exit(2);
+    }
+
+    std::ifstream stream{std::string{fixtures_dir} + "/" + path,
+                         std::ios_base::in|std::ios_base::binary};
+    if (!stream.is_open()) {
+        throw std::runtime_error{"could not open: '" + path + "'"};
+    }
+
+    const std::string message{std::istreambuf_iterator<char>(stream.rdbuf()),
+                              std::istreambuf_iterator<char>()};
+
+    stream.close();
+    return message;
+}
+
+// ---------------------------------------------------------------------------
+
+struct point_handler {
+
+    std::vector<vtzero::point> data{};
+
+    void points_begin(uint32_t count) {
+        data.reserve(count);
+    }
+
+    void points_point(const vtzero::point point) {
+        data.push_back(point);
+    }
+
+    void points_end() const noexcept {
+    }
+
+}; // struct point_handler
+
+struct linestring_handler {
+
+    std::vector<std::vector<vtzero::point>> data{};
+
+    void linestring_begin(uint32_t count) {
+        data.emplace_back();
+        data.back().reserve(count);
+    }
+
+    void linestring_point(const vtzero::point point) {
+        data.back().push_back(point);
+    }
+
+    void linestring_end() const noexcept {
+    }
+
+}; // struct linestring_handler
+
+struct polygon_handler {
+
+    std::vector<std::vector<vtzero::point>> data{};
+
+    void ring_begin(uint32_t count) {
+        data.emplace_back();
+        data.back().reserve(count);
+    }
+
+    void ring_point(const vtzero::point point) {
+        data.back().push_back(point);
+    }
+
+    void ring_end(vtzero::ring_type /*dummy*/) const noexcept {
+    }
+
+}; // struct polygon_handler
+
+// ---------------------------------------------------------------------------
+
+struct geom_handler {
+
+    std::vector<vtzero::point> point_data{};
+    std::vector<std::vector<vtzero::point>> line_data{};
+
+    void points_begin(uint32_t count) {
+        point_data.reserve(count);
+    }
+
+    void points_point(const vtzero::point point) {
+        point_data.push_back(point);
+    }
+
+    void points_end() const noexcept {
+    }
+
+    void linestring_begin(uint32_t count) {
+        line_data.emplace_back();
+        line_data.back().reserve(count);
+    }
+
+    void linestring_point(const vtzero::point point) {
+        line_data.back().push_back(point);
+    }
+
+    void linestring_end() const noexcept {
+    }
+
+    void ring_begin(uint32_t count) {
+        line_data.emplace_back();
+        line_data.back().reserve(count);
+    }
+
+    void ring_point(const vtzero::point point) {
+        line_data.back().push_back(point);
+    }
+
+    void ring_end(vtzero::ring_type /*dummy*/) const noexcept {
+    }
+
+}; // struct geom_handler
+
+// ---------------------------------------------------------------------------
+
+static vtzero::feature check_layer(vtzero::vector_tile& tile) {
+    REQUIRE_FALSE(tile.empty());
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.name() == "hello");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    return layer.next_feature();
+}
+
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MVT test 001: Empty tile") {
+    std::string buffer{open_tile("001/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.empty());
+    REQUIRE(tile.count_layers() == 0); // NOLINT(readability-container-size-empty)
+}
+
+TEST_CASE("MVT test 002: Tile with single point feature without id") {
+    std::string buffer{open_tile("002/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+
+    REQUIRE_FALSE(feature.has_id());
+    REQUIRE(feature.id() == 0);
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::POINT);
+
+    point_handler handler;
+    vtzero::decode_point_geometry(feature.geometry(), handler);
+
+    std::vector<vtzero::point> expected = {{25, 17}};
+    REQUIRE(handler.data == expected);
+}
+
+TEST_CASE("MVT test 003: Tile with single point with missing geometry type") {
+    std::string buffer{open_tile("003/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+    REQUIRE(feature.has_id());
+    REQUIRE(feature.id() == 1);
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::UNKNOWN);
+}
+
+TEST_CASE("MVT test 004: Tile with single point with missing geometry") {
+    std::string buffer{open_tile("004/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE_THROWS_AS(check_layer(tile), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 005: Tile with single point with broken tags array") {
+    std::string buffer{open_tile("005/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE_FALSE(tile.empty());
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE_FALSE(layer.empty());
+
+    REQUIRE_THROWS_AS(layer.next_feature(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 006: Tile with single point with invalid GeomType") {
+    std::string buffer{open_tile("006/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE_FALSE(layer.empty());
+
+    REQUIRE_THROWS_AS(layer.next_feature(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 007: Layer version as string instead of as an int") {
+    std::string buffer{open_tile("007/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    REQUIRE_THROWS_AS(tile.get_layer(0), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 008: Tile layer extent encoded as string") {
+    std::string buffer{open_tile("008/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    REQUIRE_THROWS_AS(tile.next_layer(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 009: Tile layer extent missing") {
+    std::string buffer{open_tile("009/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+
+    REQUIRE(layer.name() == "hello");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.id() == 1);
+}
+
+TEST_CASE("MVT test 010: Tile layer value is encoded as int, but pretends to be string") {
+    std::string buffer{open_tile("010/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE_FALSE(layer.empty());
+
+    const auto pv = layer.value(0);
+    REQUIRE_THROWS_AS(pv.type(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 011: Tile layer value is encoded as unknown type") {
+    std::string buffer{open_tile("011/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    const auto layer = tile.next_layer();
+    REQUIRE_FALSE(layer.empty());
+
+    const auto pv = layer.value(0);
+    REQUIRE_THROWS_AS(pv.type(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 012: Unknown layer version") {
+    std::string buffer{open_tile("012/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    REQUIRE_THROWS_AS(tile.next_layer(), const vtzero::version_exception&);
+}
+
+TEST_CASE("MVT test 013: Tile with key in table encoded as int") {
+    std::string buffer{open_tile("013/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    REQUIRE_THROWS_AS(tile.next_layer(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 014: Tile layer without a name") {
+    std::string buffer{open_tile("014/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    REQUIRE_THROWS_AS(tile.next_layer(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 015: Two layers with the same name") {
+    std::string buffer{open_tile("015/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 2);
+
+    while (const auto layer = tile.next_layer()) {
+        REQUIRE(layer.name() == "hello");
+    }
+
+    const auto layer = tile.get_layer_by_name("hello");
+    REQUIRE(layer.name() == "hello");
+}
+
+TEST_CASE("MVT test 016: Valid unknown geometry") {
+    std::string buffer{open_tile("016/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::UNKNOWN);
+}
+
+TEST_CASE("MVT test 017: Valid point geometry") {
+    std::string buffer{open_tile("017/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+
+    REQUIRE(feature.has_id());
+    REQUIRE(feature.id() == 1);
+
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::POINT);
+
+    const std::vector<vtzero::point> expected = {{25, 17}};
+
+    SECTION("decode_point_geometry") {
+        point_handler handler;
+        vtzero::decode_point_geometry(feature.geometry(), handler);
+        REQUIRE(handler.data == expected);
+    }
+
+    SECTION("decode_geometry") {
+        geom_handler handler;
+        vtzero::decode_geometry(feature.geometry(), handler);
+        REQUIRE(handler.point_data == expected);
+    }
+}
+
+TEST_CASE("MVT test 018: Valid linestring geometry") {
+    std::string buffer = open_tile("018/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::LINESTRING);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{2, 2}, {2,10}, {10, 10}}};
+
+    SECTION("decode_linestring_geometry") {
+        linestring_handler handler;
+        vtzero::decode_linestring_geometry(feature.geometry(), handler);
+        REQUIRE(handler.data == expected);
+    }
+
+    SECTION("decode_geometry") {
+        geom_handler handler;
+        vtzero::decode_geometry(feature.geometry(), handler);
+        REQUIRE(handler.line_data == expected);
+    }
+}
+
+TEST_CASE("MVT test 019: Valid polygon geometry") {
+    std::string buffer = open_tile("019/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::POLYGON);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{3, 6}, {8,12}, {20, 34}, {3, 6}}};
+
+    SECTION("deocode_polygon_geometry") {
+        polygon_handler handler;
+        vtzero::decode_polygon_geometry(feature.geometry(), handler);
+        REQUIRE(handler.data == expected);
+    }
+
+    SECTION("deocode_geometry") {
+        geom_handler handler;
+        vtzero::decode_geometry(feature.geometry(), handler);
+        REQUIRE(handler.line_data == expected);
+    }
+}
+
+TEST_CASE("MVT test 020: Valid multipoint geometry") {
+    std::string buffer = open_tile("020/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::POINT);
+
+    point_handler handler;
+    vtzero::decode_point_geometry(feature.geometry(), handler);
+
+    const std::vector<vtzero::point> expected = {{5, 7}, {3,2}};
+
+    REQUIRE(handler.data == expected);
+}
+
+TEST_CASE("MVT test 021: Valid multilinestring geometry") {
+    std::string buffer = open_tile("021/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::LINESTRING);
+
+    linestring_handler handler;
+    vtzero::decode_linestring_geometry(feature.geometry(), handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{2, 2}, {2,10}, {10, 10}}, {{1,1}, {3, 5}}};
+
+    REQUIRE(handler.data == expected);
+}
+
+TEST_CASE("MVT test 022: Valid multipolygon geometry") {
+    std::string buffer = open_tile("022/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    const auto feature = check_layer(tile);
+
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::POLYGON);
+
+    polygon_handler handler;
+    vtzero::decode_polygon_geometry(feature.geometry(), handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {
+        {{0, 0}, {10, 0}, {10, 10}, {0,10}, {0, 0}},
+        {{11, 11}, {20, 11}, {20, 20}, {11, 20}, {11, 11}},
+        {{13, 13}, {13, 17}, {17, 17}, {17, 13}, {13, 13}}
+    };
+
+    REQUIRE(handler.data == expected);
+}
+
+TEST_CASE("MVT test 023: Invalid layer: missing layer name") {
+    std::string buffer = open_tile("023/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    REQUIRE_THROWS_AS(tile.next_layer(), const vtzero::format_exception&);
+    REQUIRE_THROWS_AS(tile.get_layer_by_name("foo"), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 024: Missing layer version") {
+    std::string buffer = open_tile("024/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    const auto layer = tile.next_layer();
+    REQUIRE(layer.version() == 1);
+}
+
+TEST_CASE("MVT test 025: Layer without features") {
+    std::string buffer = open_tile("025/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    const auto layer = tile.next_layer();
+    REQUIRE(layer.empty());
+    REQUIRE(layer.num_features() == 0); // NOLINT(readability-container-size-empty)
+}
+
+TEST_CASE("MVT test 026: Extra value type") {
+    std::string buffer = open_tile("026/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.empty());
+
+    const auto& table = layer.value_table();
+    REQUIRE(table.size() == 1);
+
+    const auto pvv = table[0];
+    REQUIRE(pvv.valid());
+    REQUIRE_THROWS_AS(pvv.type(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 027: Layer with unused bool property value") {
+    std::string buffer{open_tile("027/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 0); // NOLINT(readability-container-size-empty)
+
+    const auto& vtab = layer.value_table();
+    REQUIRE(vtab.size() == 1);
+    REQUIRE(vtab[0].bool_value());
+}
+
+TEST_CASE("MVT test 030: Two geometry fields") {
+    std::string buffer = open_tile("030/tile.mvt");
+    vtzero::vector_tile tile{buffer};
+
+    auto layer = tile.next_layer();
+    REQUIRE_FALSE(layer.empty());
+
+    REQUIRE_THROWS_AS(layer.next_feature(), const vtzero::format_exception&);
+}
+
+TEST_CASE("MVT test 032: Layer with single feature with string property value") {
+    std::string buffer{open_tile("032/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE_FALSE(tile.empty());
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+
+    auto prop = feature.next_property();
+    REQUIRE(prop.key() == "key1");
+    REQUIRE(prop.value().string_value() == "i am a string value");
+
+    feature.reset_property();
+    auto ii = feature.next_property_indexes();
+    REQUIRE(ii);
+    REQUIRE(ii.key().value() == 0);
+    REQUIRE(ii.value().value() == 0);
+    REQUIRE_FALSE(feature.next_property_indexes());
+}
+
+TEST_CASE("MVT test 033: Layer with single feature with float property value") {
+    std::string buffer{open_tile("033/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+
+    const auto prop = feature.next_property();
+    REQUIRE(prop.key() == "key1");
+    REQUIRE(prop.value().float_value() == Approx(3.1));
+}
+
+TEST_CASE("MVT test 034: Layer with single feature with double property value") {
+    std::string buffer{open_tile("034/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+
+    const auto prop = feature.next_property();
+    REQUIRE(prop.key() == "key1");
+    REQUIRE(prop.value().double_value() == Approx(1.23));
+}
+
+TEST_CASE("MVT test 035: Layer with single feature with int property value") {
+    std::string buffer{open_tile("035/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+
+    const auto prop = feature.next_property();
+    REQUIRE(prop.key() == "key1");
+    REQUIRE(prop.value().int_value() == 6);
+}
+
+TEST_CASE("MVT test 036: Layer with single feature with uint property value") {
+    std::string buffer{open_tile("036/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+
+    const auto prop = feature.next_property();
+    REQUIRE(prop.key() == "key1");
+    REQUIRE(prop.value().uint_value() == 87948);
+}
+
+TEST_CASE("MVT test 037: Layer with single feature with sint property value") {
+    std::string buffer{open_tile("037/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+
+    const auto prop = feature.next_property();
+    REQUIRE(prop.key() == "key1");
+    REQUIRE(prop.value().sint_value() == 87948);
+}
+
+TEST_CASE("MVT test 038: Layer with all types of property value") {
+    std::string buffer{open_tile("038/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+
+    const auto& vtab = layer.value_table();
+    REQUIRE(vtab.size() == 7);
+    REQUIRE(vtab[0].string_value() == "ello");
+    REQUIRE(vtab[1].bool_value());
+    REQUIRE(vtab[2].int_value() == 6);
+    REQUIRE(vtab[3].double_value() == Approx(1.23));
+    REQUIRE(vtab[4].float_value() == Approx(3.1));
+    REQUIRE(vtab[5].sint_value() == -87948);
+    REQUIRE(vtab[6].uint_value() == 87948);
+
+    REQUIRE_THROWS_AS(vtab[0].bool_value(), const vtzero::type_exception&);
+    REQUIRE_THROWS_AS(vtab[0].int_value(), const vtzero::type_exception&);
+    REQUIRE_THROWS_AS(vtab[0].double_value(), const vtzero::type_exception&);
+    REQUIRE_THROWS_AS(vtab[0].float_value(), const vtzero::type_exception&);
+    REQUIRE_THROWS_AS(vtab[0].sint_value(), const vtzero::type_exception&);
+    REQUIRE_THROWS_AS(vtab[0].uint_value(), const vtzero::type_exception&);
+    REQUIRE_THROWS_AS(vtab[1].string_value(), const vtzero::type_exception&);
+}
+
+TEST_CASE("MVT test 039: Default values are actually encoded in the tile") {
+    std::string buffer{open_tile("039/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.version() == 1);
+    REQUIRE(layer.name() == "hello");
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.id() == 0);
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::UNKNOWN);
+    REQUIRE(feature.empty());
+
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(feature.geometry(), geom_handler{}), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("MVT test 040: Feature has tags that point to non-existent Key in the layer.") {
+    std::string buffer{open_tile("040/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+    REQUIRE_THROWS_AS(feature.next_property(), const vtzero::out_of_range_exception&);
+}
+
+TEST_CASE("MVT test 040: Feature has tags that point to non-existent Key in the layer decoded using next_property_indexes().") {
+    std::string buffer{open_tile("040/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+    REQUIRE_THROWS_AS(feature.next_property_indexes(), const vtzero::out_of_range_exception&);
+}
+
+TEST_CASE("MVT test 041: Tags encoded as floats instead of as ints") {
+    std::string buffer{open_tile("041/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+    auto feature = layer.next_feature();
+    REQUIRE_THROWS_AS(feature.next_property(), const vtzero::out_of_range_exception&);
+}
+
+TEST_CASE("MVT test 042: Feature has tags that point to non-existent Value in the layer.") {
+    std::string buffer{open_tile("042/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+    auto feature = layer.next_feature();
+    REQUIRE(feature.num_properties() == 1);
+    REQUIRE_THROWS_AS(feature.next_property(), const vtzero::out_of_range_exception&);
+}
+
+TEST_CASE("MVT test 043: A layer with six points that all share the same key but each has a unique value.") {
+    std::string buffer{open_tile("043/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 6);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+    REQUIRE(feature.num_properties() == 1);
+
+    auto property = feature.next_property();
+    REQUIRE(property);
+    REQUIRE(property.key() == "poi");
+    REQUIRE(property.value().string_value() == "swing");
+
+    feature = layer.next_feature();
+    REQUIRE(feature);
+
+    property = feature.next_property();
+    REQUIRE(property);
+    REQUIRE(property.key() == "poi");
+    REQUIRE(property.value().string_value() == "water_fountain");
+}
+
+TEST_CASE("MVT test 044: Geometry field begins with a ClosePath command, which is invalid") {
+    std::string buffer{open_tile("044/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("MVT test 045: Invalid point geometry that includes a MoveTo command and only half of the xy coordinates") {
+    std::string buffer{open_tile("045/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(vtzero::decode_geometry(geometry, geom_handler{}), "too few points in geometry");
+}
+
+TEST_CASE("MVT test 046: Invalid linestring geometry that includes two points in the same position, which is not OGC valid") {
+    std::string buffer{open_tile("046/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+
+    geom_handler handler;
+    vtzero::decode_geometry(geometry, handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{2, 2}, {2, 10}, {2, 10}}};
+    REQUIRE(handler.line_data == expected);
+}
+
+TEST_CASE("MVT test 047: Invalid polygon with wrong ClosePath count 2 (must be count 1)") {
+    std::string buffer{open_tile("047/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(vtzero::decode_geometry(geometry, geom_handler{}), "ClosePath command count is not 1");
+}
+
+TEST_CASE("MVT test 048: Invalid polygon with wrong ClosePath count 0 (must be count 1)") {
+    std::string buffer{open_tile("048/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(vtzero::decode_geometry(geometry, geom_handler{}), "ClosePath command count is not 1");
+}
+
+TEST_CASE("MVT test 049: decoding linestring with int32 overflow in x coordinate") {
+    std::string buffer{open_tile("049/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+
+    geom_handler handler;
+    vtzero::decode_geometry(geometry, handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{std::numeric_limits<int32_t>::max(), 0}, {std::numeric_limits<int32_t>::min(), 1}}};
+    REQUIRE(handler.line_data == expected);
+}
+
+TEST_CASE("MVT test 050: decoding linestring with int32 overflow in y coordinate") {
+    std::string buffer{open_tile("050/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+
+    geom_handler handler;
+    vtzero::decode_geometry(geometry, handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{0, std::numeric_limits<int32_t>::min()}, {-1, std::numeric_limits<int32_t>::max()}}};
+    REQUIRE(handler.line_data == expected);
+}
+
+TEST_CASE("MVT test 051: multipoint with a huge count value, useful for ensuring no over-allocation errors. Example error message \"count too large\"") {
+    std::string buffer{open_tile("051/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(vtzero::decode_geometry(geometry, geom_handler{}), "count too large");
+}
+
+TEST_CASE("MVT test 052: multipoint with not enough points") {
+    std::string buffer{open_tile("052/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("MVT test 053: clipped square (exact extent): a polygon that covers the entire tile to the exact boundary") {
+    std::string buffer{open_tile("053/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+
+    geom_handler handler;
+    vtzero::decode_geometry(geometry, handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{0, 0}, {4096, 0}, {4096, 4096}, {0, 4096}, {0, 0}}};
+    REQUIRE(handler.line_data == expected);
+}
+
+TEST_CASE("MVT test 054: clipped square (one unit buffer): a polygon that covers the entire tile plus a one unit buffer") {
+    std::string buffer{open_tile("054/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+
+    geom_handler handler;
+    vtzero::decode_geometry(geometry, handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{-1, -1}, {4097, -1}, {4097, 4097}, {-1, 4097}, {-1, -1}}};
+    REQUIRE(handler.line_data == expected);
+}
+
+TEST_CASE("MVT test 055: clipped square (minus one unit buffer): a polygon that almost covers the entire tile minus one unit buffer") {
+    std::string buffer{open_tile("055/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+
+    geom_handler handler;
+    vtzero::decode_geometry(geometry, handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{1, 1}, {4095, 1}, {4095, 4095}, {1, 4095}, {1, 1}}};
+    REQUIRE(handler.line_data == expected);
+}
+
+TEST_CASE("MVT test 056: clipped square (large buffer): a polygon that covers the entire tile plus a 200 unit buffer") {
+    std::string buffer{open_tile("056/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+
+    geom_handler handler;
+    vtzero::decode_geometry(geometry, handler);
+
+    const std::vector<std::vector<vtzero::point>> expected = {{{-200, -200}, {4296, -200}, {4296, 4296}, {-200, 4296}, {-200, -200}}};
+    REQUIRE(handler.line_data == expected);
+}
+
+TEST_CASE("MVT test 057: A point fixture with a gigantic MoveTo command. Can be used to test decoders for memory overallocation situations") {
+    std::string buffer{open_tile("057/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(vtzero::decode_geometry(geometry, geom_handler{}), "count too large");
+}
+
+TEST_CASE("MVT test 058: A linestring fixture with a gigantic LineTo command") {
+    std::string buffer{open_tile("058/tile.mvt")};
+    vtzero::vector_tile tile{buffer};
+    REQUIRE(tile.count_layers() == 1);
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+
+    const auto geometry = feature.geometry();
+    REQUIRE_THROWS_AS(vtzero::decode_geometry(geometry, geom_handler{}), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(vtzero::decode_geometry(geometry, geom_handler{}), "count too large");
+}
+
diff --git a/third_party/vtzero/test/include/test.hpp b/third_party/vtzero/test/include/test.hpp
new file mode 100644
index 00000000000..33bb921ea0a
--- /dev/null
+++ b/third_party/vtzero/test/include/test.hpp
@@ -0,0 +1,37 @@
+#ifndef TEST_HPP
+#define TEST_HPP
+
+#include <catch.hpp>
+
+#include <stdexcept>
+
+// Define vtzero_assert() to throw this error. This allows the tests to
+// check that the assert fails.
+struct assert_error : public std::runtime_error {
+    explicit assert_error(const char* what_arg) : std::runtime_error(what_arg) {
+    }
+};
+
+#define vtzero_assert(x) if (!(x)) { throw assert_error{#x}; }
+
+#define vtzero_assert_in_noexcept_function(x) if (!(x)) { got_an_assert = true; }
+
+extern bool got_an_assert;
+
+#define REQUIRE_ASSERT(x) x; REQUIRE(got_an_assert); got_an_assert = false;
+
+#include <vtzero/output.hpp>
+
+std::string load_test_tile();
+
+struct mypoint {
+    int64_t p1;
+    int64_t p2;
+};
+
+inline vtzero::point create_vtzero_point(mypoint p) noexcept {
+    return {static_cast<int32_t>(p.p1),
+            static_cast<int32_t>(p.p2)};
+}
+
+#endif // TEST_HPP
diff --git a/third_party/vtzero/test/t/test_builder.cpp b/third_party/vtzero/test/t/test_builder.cpp
new file mode 100644
index 00000000000..1dbd7f75b0d
--- /dev/null
+++ b/third_party/vtzero/test/t/test_builder.cpp
@@ -0,0 +1,408 @@
+
+#include <test.hpp>
+
+#include <vtzero/builder.hpp>
+#include <vtzero/index.hpp>
+#include <vtzero/output.hpp>
+
+#include <cstdint>
+#include <string>
+#include <type_traits>
+
+template <typename T>
+struct movable_not_copyable {
+    constexpr static bool value = !std::is_copy_constructible<T>::value &&
+                                  !std::is_copy_assignable<T>::value    &&
+                                   std::is_nothrow_move_constructible<T>::value &&
+                                   std::is_nothrow_move_assignable<T>::value;
+};
+
+static_assert(movable_not_copyable<vtzero::tile_builder>::value, "tile_builder should be nothrow movable, but not copyable");
+static_assert(movable_not_copyable<vtzero::point_feature_builder>::value, "point_feature_builder should be nothrow movable, but not copyable");
+static_assert(movable_not_copyable<vtzero::linestring_feature_builder>::value, "linestring_feature_builder should be nothrow movable, but not copyable");
+static_assert(movable_not_copyable<vtzero::polygon_feature_builder>::value, "polygon_feature_builder should be nothrow movable, but not copyable");
+static_assert(movable_not_copyable<vtzero::geometry_feature_builder>::value, "geometry_feature_builder should be nothrow movable, but not copyable");
+
+TEST_CASE("Create tile from existing layers") {
+    const auto buffer = load_test_tile();
+    vtzero::vector_tile tile{buffer};
+
+    vtzero::tile_builder tbuilder;
+
+    SECTION("add_existing_layer(layer)") {
+        while (auto layer = tile.next_layer()) {
+            tbuilder.add_existing_layer(layer);
+        }
+    }
+
+    SECTION("add_existing_layer(data_view)") {
+        while (auto layer = tile.next_layer()) {
+            tbuilder.add_existing_layer(layer.data());
+        }
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    REQUIRE(data == buffer);
+}
+
+TEST_CASE("Create layer based on existing layer") {
+    const auto buffer = load_test_tile();
+    vtzero::vector_tile tile{buffer};
+    const auto layer = tile.get_layer_by_name("place_label");
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, layer};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+    fbuilder.set_id(42);
+    fbuilder.add_point(10, 20);
+    fbuilder.commit();
+
+    const std::string data = tbuilder.serialize();
+    vtzero::vector_tile new_tile{data};
+    const auto new_layer = new_tile.next_layer();
+    REQUIRE(std::string(new_layer.name()) == "place_label");
+    REQUIRE(new_layer.version() == 1);
+    REQUIRE(new_layer.extent() == 4096);
+}
+
+TEST_CASE("Create layer and add keys/values") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "name"};
+
+    const auto ki1 = lbuilder.add_key_without_dup_check("key1");
+    const auto ki2 = lbuilder.add_key("key2");
+    const auto ki3 = lbuilder.add_key("key1");
+
+    REQUIRE(ki1 != ki2);
+    REQUIRE(ki1 == ki3);
+
+    const auto vi1 = lbuilder.add_value_without_dup_check(vtzero::encoded_property_value{"value1"});
+    vtzero::encoded_property_value value2{"value2"};
+    const auto vi2 = lbuilder.add_value_without_dup_check(vtzero::property_value{value2.data()});
+
+    const auto vi3 = lbuilder.add_value(vtzero::encoded_property_value{"value1"});
+    const auto vi4 = lbuilder.add_value(vtzero::encoded_property_value{19});
+    const auto vi5 = lbuilder.add_value(vtzero::encoded_property_value{19.0});
+    const auto vi6 = lbuilder.add_value(vtzero::encoded_property_value{22});
+    vtzero::encoded_property_value nineteen{19};
+    const auto vi7 = lbuilder.add_value(vtzero::property_value{nineteen.data()});
+
+    REQUIRE(vi1 != vi2);
+    REQUIRE(vi1 == vi3);
+    REQUIRE(vi1 != vi4);
+    REQUIRE(vi1 != vi5);
+    REQUIRE(vi1 != vi6);
+    REQUIRE(vi4 != vi5);
+    REQUIRE(vi4 != vi6);
+    REQUIRE(vi4 == vi7);
+}
+
+TEST_CASE("Committing a feature succeeds after a geometry was added") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    { // explicit commit after geometry
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(1);
+        fbuilder.add_point(10, 10);
+        fbuilder.commit();
+    }
+
+    { // explicit commit after properties
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(2);
+        fbuilder.add_point(10, 10);
+        fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+        fbuilder.commit();
+    }
+
+    { // extra commits or rollbacks are okay but no other calls
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(3);
+        fbuilder.add_point(10, 10);
+        fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+        fbuilder.commit();
+
+        SECTION("superfluous commit()") {
+            fbuilder.commit();
+        }
+        SECTION("superfluous rollback()") {
+            fbuilder.rollback();
+        }
+
+        REQUIRE_THROWS_AS(fbuilder.set_id(10), const assert_error&);
+        REQUIRE_THROWS_AS(fbuilder.add_point(20, 20), const assert_error&);
+        REQUIRE_THROWS_AS(fbuilder.add_property("x", "y"), const assert_error&);
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+    auto layer = tile.next_layer();
+
+    uint64_t n = 1;
+    while (auto feature = layer.next_feature()) {
+        REQUIRE(feature.id() == n++);
+    }
+
+    REQUIRE(n == 4);
+}
+
+TEST_CASE("Committing a feature fails with assert if no geometry was added") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    SECTION("explicit immediate commit") {
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        REQUIRE_THROWS_AS(fbuilder.commit(), const assert_error&);
+    }
+
+    SECTION("explicit commit after setting id") {
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(2);
+        REQUIRE_THROWS_AS(fbuilder.commit(), const assert_error&);
+    }
+}
+
+TEST_CASE("Rollback feature") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(1);
+        fbuilder.add_point(10, 10);
+        fbuilder.commit();
+    }
+
+    { // immediate rollback
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(2);
+        fbuilder.rollback();
+    }
+
+    { // rollback after setting id
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(3);
+        fbuilder.rollback();
+    }
+
+    { // rollback after geometry
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(4);
+        fbuilder.add_point(20, 20);
+        fbuilder.rollback();
+    }
+
+    { // rollback after properties
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(5);
+        fbuilder.add_point(20, 20);
+        fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+        fbuilder.rollback();
+    }
+
+    { // implicit rollback after geometry
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(6);
+        fbuilder.add_point(10, 10);
+    }
+
+    { // implicit rollback after properties
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(7);
+        fbuilder.add_point(10, 10);
+        fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+    }
+
+    {
+        vtzero::point_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(8);
+        fbuilder.add_point(30, 30);
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+    auto layer = tile.next_layer();
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.id() == 1);
+
+    feature = layer.next_feature();
+    REQUIRE(feature.id() == 8);
+
+    feature = layer.next_feature();
+    REQUIRE_FALSE(feature);
+}
+
+static bool vector_tile_equal(const std::string& t1, const std::string& t2) {
+    vtzero::vector_tile vt1{t1};
+    vtzero::vector_tile vt2{t2};
+
+    for (auto l1 = vt1.next_layer(), l2 = vt2.next_layer();
+         l1 && l2;
+         l1 = vt1.next_layer(), l2 = vt2.next_layer()) {
+        if (l1.empty()) {
+            l1 = vt1.next_layer();
+            if (!l1) {
+                return true;
+            }
+        }
+        if (l2.empty()) {
+            l2 = vt2.next_layer();
+            if (!l2) {
+                return true;
+            }
+        }
+
+        if (!l1 ||
+            !l2 ||
+            l1.version() != l2.version() ||
+            l1.extent() != l2.extent() ||
+            l1.num_features() != l2.num_features() ||
+            l1.name() != l2.name()) {
+            return false;
+        }
+
+        for (auto f1 = l1.next_feature(), f2 = l2.next_feature();
+             f1 && f2;
+             f1 = l1.next_feature(), f2 = l2.next_feature()) {
+            if (f1.id() != f2.id() ||
+                f1.geometry_type() != f2.geometry_type() ||
+                f1.num_properties() != f2.num_properties() ||
+                f1.geometry().data() != f2.geometry().data()) {
+                return false;
+            }
+            for (auto p1 = f1.next_property(), p2 = f2.next_property();
+                p1 && p2;
+                p1 = f1.next_property(), p2 = f2.next_property()) {
+                if (p1.key() != p2.key() || p1.value() != p2.value()) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+TEST_CASE("Copy tile") {
+    const auto buffer = load_test_tile();
+    vtzero::vector_tile tile{buffer};
+
+    vtzero::tile_builder tbuilder;
+
+    while (auto layer = tile.next_layer()) {
+        vtzero::layer_builder lbuilder{tbuilder, layer};
+        while (auto feature = layer.next_feature()) {
+            lbuilder.add_feature(feature);
+        }
+    }
+
+    const std::string data = tbuilder.serialize();
+    REQUIRE(vector_tile_equal(buffer, data));
+}
+
+TEST_CASE("Copy tile using geometry_feature_builder") {
+    const auto buffer = load_test_tile();
+    vtzero::vector_tile tile{buffer};
+
+    vtzero::tile_builder tbuilder;
+
+    while (auto layer = tile.next_layer()) {
+        vtzero::layer_builder lbuilder{tbuilder, layer};
+        while (auto feature = layer.next_feature()) {
+            vtzero::geometry_feature_builder fbuilder{lbuilder};
+            fbuilder.set_id(feature.id());
+            fbuilder.set_geometry(feature.geometry());
+            while (auto property = feature.next_property()) {
+                fbuilder.add_property(property.key(), property.value());
+            }
+            fbuilder.commit();
+        }
+    }
+
+    const std::string data = tbuilder.serialize();
+    REQUIRE(vector_tile_equal(buffer, data));
+}
+
+TEST_CASE("Copy only point geometries using geometry_feature_builder") {
+    const auto buffer = load_test_tile();
+    vtzero::vector_tile tile{buffer};
+
+    vtzero::tile_builder tbuilder;
+
+    int n = 0;
+    while (auto layer = tile.next_layer()) {
+        vtzero::layer_builder lbuilder{tbuilder, layer};
+        while (auto feature = layer.next_feature()) {
+            vtzero::geometry_feature_builder fbuilder{lbuilder};
+            fbuilder.set_id(feature.id());
+            if (feature.geometry().type() == vtzero::GeomType::POINT) {
+                fbuilder.set_geometry(feature.geometry());
+                while (auto property = feature.next_property()) {
+                    fbuilder.add_property(property.key(), property.value());
+                }
+                fbuilder.commit();
+                ++n;
+            } else {
+                fbuilder.rollback();
+            }
+        }
+    }
+    REQUIRE(n == 17);
+
+    const std::string data = tbuilder.serialize();
+
+    n = 0;
+    vtzero::vector_tile result_tile{data};
+    while (auto layer = result_tile.next_layer()) {
+        while (auto feature = layer.next_feature()) {
+            ++n;
+        }
+    }
+
+    REQUIRE(n == 17);
+}
+
+TEST_CASE("Build point feature from container with too many points") {
+
+    // fake container pretending to contain too many points
+    struct test_container {
+
+        std::size_t size() const noexcept {
+            return 1ul << 29u;
+        }
+
+        vtzero::point* begin() const noexcept {
+            return nullptr;
+        }
+
+        vtzero::point* end() const noexcept {
+            return nullptr;
+        }
+
+    };
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    fbuilder.set_id(1);
+
+    test_container tc;
+    REQUIRE_THROWS_AS(fbuilder.add_points_from_container(tc), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("Moving a feature builder is allowed") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    auto fbuilder2 = std::move(fbuilder);
+    vtzero::point_feature_builder fbuilder3{std::move(fbuilder2)};
+}
+
diff --git a/third_party/vtzero/test/t/test_builder_linestring.cpp b/third_party/vtzero/test/t/test_builder_linestring.cpp
new file mode 100644
index 00000000000..917fd6f3a6b
--- /dev/null
+++ b/third_party/vtzero/test/t/test_builder_linestring.cpp
@@ -0,0 +1,312 @@
+
+#include <test.hpp>
+
+#include <vtzero/builder.hpp>
+#include <vtzero/geometry.hpp>
+#include <vtzero/index.hpp>
+
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+using ls_type = std::vector<std::vector<vtzero::point>>;
+
+struct linestring_handler {
+
+    ls_type data;
+
+    void linestring_begin(uint32_t count) {
+        data.emplace_back();
+        data.back().reserve(count);
+    }
+
+    void linestring_point(const vtzero::point point) {
+        data.back().push_back(point);
+    }
+
+    void linestring_end() const noexcept {
+    }
+
+};
+
+static void test_linestring_builder(bool with_id, bool with_prop) {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+        if (with_id) {
+            fbuilder.set_id(17);
+        }
+
+        fbuilder.add_linestring(3);
+        fbuilder.set_point(10, 20);
+        fbuilder.set_point(vtzero::point{20, 30});
+        fbuilder.set_point(mypoint{30, 40});
+
+        if (with_prop) {
+            fbuilder.add_property("foo", "bar");
+        }
+
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.id() == (with_id ? 17 : 0));
+
+    linestring_handler handler;
+    vtzero::decode_linestring_geometry(feature.geometry(), handler);
+
+    const ls_type result = {{{10, 20}, {20, 30}, {30, 40}}};
+    REQUIRE(handler.data == result);
+}
+
+TEST_CASE("linestring builder without id/without properties") {
+    test_linestring_builder(false, false);
+}
+
+TEST_CASE("linestring builder without id/with properties") {
+    test_linestring_builder(false, true);
+}
+
+TEST_CASE("linestring builder with id/without properties") {
+    test_linestring_builder(true, false);
+}
+
+TEST_CASE("linestring builder with id/with properties") {
+    test_linestring_builder(true, true);
+}
+
+TEST_CASE("Calling add_linestring() with bad values throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+    SECTION("0") {
+        REQUIRE_THROWS_AS(fbuilder.add_linestring(0), const assert_error&);
+    }
+    SECTION("1") {
+        REQUIRE_THROWS_AS(fbuilder.add_linestring(1), const assert_error&);
+    }
+    SECTION("2^29") {
+        REQUIRE_THROWS_AS(fbuilder.add_linestring(1ul << 29u), const assert_error&);
+    }
+}
+
+static void test_multilinestring_builder(bool with_id, bool with_prop) {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+    if (with_id) {
+        fbuilder.set_id(17);
+    }
+
+    fbuilder.add_linestring(3);
+    fbuilder.set_point(10, 20);
+    fbuilder.set_point(vtzero::point{20, 30});
+    fbuilder.set_point(mypoint{30, 40});
+
+    fbuilder.add_linestring(2);
+    fbuilder.set_point(1, 2);
+    fbuilder.set_point(2, 1);
+
+    if (with_prop) {
+        fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+    }
+
+    fbuilder.commit();
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.id() == (with_id ? 17 : 0));
+
+    linestring_handler handler;
+    vtzero::decode_linestring_geometry(feature.geometry(), handler);
+
+    const ls_type result = {{{10, 20}, {20, 30}, {30, 40}}, {{1, 2}, {2, 1}}};
+    REQUIRE(handler.data == result);
+}
+
+
+TEST_CASE("Multilinestring builder without id/without properties") {
+    test_multilinestring_builder(false, false);
+}
+
+TEST_CASE("Multilinestring builder without id/with properties") {
+    test_multilinestring_builder(false, true);
+}
+
+TEST_CASE("Multilinestring builder with id/without properties") {
+    test_multilinestring_builder(true, false);
+}
+
+TEST_CASE("Multilinestring builder with id/with properties") {
+    test_multilinestring_builder(true, true);
+}
+
+TEST_CASE("Calling add_linestring() twice throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_linestring(3);
+    REQUIRE_ASSERT(fbuilder.add_linestring(2));
+}
+
+TEST_CASE("Calling linestring_feature_builder::set_point() throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+    REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const assert_error&);
+}
+
+TEST_CASE("Calling linestring_feature_builder::set_point() with same point throws") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_linestring(2);
+    fbuilder.set_point(10, 10);
+    REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("Calling linestring_feature_builder::set_point() too often throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_linestring(2);
+    fbuilder.set_point(10, 20);
+    fbuilder.set_point(20, 20);
+    REQUIRE_THROWS_AS(fbuilder.set_point(30, 20), const assert_error&);
+}
+
+TEST_CASE("Add linestring from container") {
+    const ls_type points = {{{10, 20}, {20, 30}, {30, 40}}};
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+#if 0
+        SECTION("using iterators") {
+            fbuilder.add_linestring(points[0].cbegin(), points[0].cend());
+        }
+
+        SECTION("using iterators and size") {
+            fbuilder.add_linestring(points[0].cbegin(), points[0].cend(), static_cast<uint32_t>(points[0].size()));
+        }
+#endif
+
+        SECTION("using container directly") {
+            fbuilder.add_linestring_from_container(points[0]);
+        }
+
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+
+    linestring_handler handler;
+    vtzero::decode_linestring_geometry(feature.geometry(), handler);
+
+    REQUIRE(handler.data == points);
+}
+
+#if 0
+TEST_CASE("Add linestring from iterator with wrong count throws assert") {
+    const std::vector<vtzero::point> points = {{10, 20}, {20, 30}, {30, 40}};
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::linestring_feature_builder fbuilder{lbuilder};
+
+    REQUIRE_THROWS_AS(fbuilder.add_linestring(points.cbegin(),
+                                              points.cend(),
+                                              static_cast<uint32_t>(points.size() + 1)), const assert_error&);
+}
+#endif
+
+TEST_CASE("Adding several linestrings with feature rollback in the middle") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::linestring_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(1);
+        fbuilder.add_linestring(2);
+        fbuilder.set_point(10, 10);
+        fbuilder.set_point(20, 20);
+        fbuilder.commit();
+    }
+
+    try {
+        vtzero::linestring_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(2);
+        fbuilder.add_linestring(2);
+        fbuilder.set_point(10, 10);
+        fbuilder.set_point(10, 10);
+        fbuilder.commit();
+    } catch (vtzero::geometry_exception&) {
+    }
+
+    {
+        vtzero::linestring_feature_builder fbuilder{lbuilder};
+        fbuilder.set_id(3);
+        fbuilder.add_linestring(2);
+        fbuilder.set_point(10, 20);
+        fbuilder.set_point(20, 10);
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.num_features() == 2);
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.id() == 1);
+    feature = layer.next_feature();
+    REQUIRE(feature.id() == 3);
+}
+
diff --git a/third_party/vtzero/test/t/test_builder_point.cpp b/third_party/vtzero/test/t/test_builder_point.cpp
new file mode 100644
index 00000000000..ac3fa5aca02
--- /dev/null
+++ b/third_party/vtzero/test/t/test_builder_point.cpp
@@ -0,0 +1,279 @@
+
+#include <test.hpp>
+
+#include <vtzero/builder.hpp>
+#include <vtzero/geometry.hpp>
+#include <vtzero/index.hpp>
+
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+struct point_handler {
+
+    std::vector<vtzero::point> data;
+
+    void points_begin(uint32_t count) {
+        data.reserve(count);
+    }
+
+    void points_point(const vtzero::point point) {
+        data.push_back(point);
+    }
+
+    void points_end() const noexcept {
+    }
+
+};
+
+static void test_point_builder(bool with_id, bool with_prop) {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::point_feature_builder fbuilder{lbuilder};
+
+        if (with_id) {
+            fbuilder.set_id(17);
+        }
+
+        SECTION("add point using coordinates / property using key/value") {
+            fbuilder.add_point(10, 20);
+            if (with_prop) {
+                fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+            }
+        }
+
+        SECTION("add point using vtzero::point / property using key/value") {
+            fbuilder.add_point(vtzero::point{10, 20});
+            if (with_prop) {
+                fbuilder.add_property("foo", vtzero::encoded_property_value{22});
+            }
+        }
+
+        SECTION("add point using mypoint / property using property") {
+            vtzero::encoded_property_value pv{3.5};
+            vtzero::property p{"foo", vtzero::property_value{pv.data()}};
+            fbuilder.add_point(mypoint{10, 20});
+            if (with_prop) {
+                fbuilder.add_property(p);
+            }
+        }
+
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.id() == (with_id ? 17 : 0));
+
+    point_handler handler;
+    vtzero::decode_point_geometry(feature.geometry(), handler);
+
+    const std::vector<vtzero::point> result = {{10, 20}};
+    REQUIRE(handler.data == result);
+}
+
+TEST_CASE("Point builder without id/without properties") {
+    test_point_builder(false, false);
+}
+
+TEST_CASE("Point builder without id/with properties") {
+    test_point_builder(false, true);
+}
+
+TEST_CASE("Point builder with id/without properties") {
+    test_point_builder(true, false);
+}
+
+TEST_CASE("Point builder with id/with properties") {
+    test_point_builder(true, true);
+}
+
+TEST_CASE("Calling add_points() with bad values throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    SECTION("0") {
+        REQUIRE_THROWS_AS(fbuilder.add_points(0), const assert_error&);
+    }
+    SECTION("2^29") {
+        REQUIRE_THROWS_AS(fbuilder.add_points(1ul << 29u), const assert_error&);
+    }
+}
+
+static void test_multipoint_builder(bool with_id, bool with_prop) {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    if (with_id) {
+        fbuilder.set_id(17);
+    }
+
+    fbuilder.add_points(3);
+    fbuilder.set_point(10, 20);
+    fbuilder.set_point(vtzero::point{20, 30});
+    fbuilder.set_point(mypoint{30, 40});
+
+    if (with_prop) {
+        fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+    }
+
+    fbuilder.commit();
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.id() == (with_id ? 17 : 0));
+
+    point_handler handler;
+    vtzero::decode_point_geometry(feature.geometry(), handler);
+
+    const std::vector<vtzero::point> result = {{10, 20}, {20, 30}, {30, 40}};
+    REQUIRE(handler.data == result);
+}
+
+
+TEST_CASE("Multipoint builder without id/without properties") {
+    test_multipoint_builder(false, false);
+}
+
+TEST_CASE("Multipoint builder without id/with properties") {
+    test_multipoint_builder(false, true);
+}
+
+TEST_CASE("Multipoint builder with id/without properties") {
+    test_multipoint_builder(true, false);
+}
+
+TEST_CASE("Multipoint builder with id/with properties") {
+    test_multipoint_builder(true, true);
+}
+
+TEST_CASE("Calling add_point() and then other geometry functions throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_point(10, 20);
+
+    SECTION("add_point()") {
+        REQUIRE_THROWS_AS(fbuilder.add_point(10, 20), const assert_error&);
+    }
+    SECTION("add_points()") {
+        REQUIRE_THROWS_AS(fbuilder.add_points(2), const assert_error&);
+    }
+    SECTION("set_point()") {
+        REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const assert_error&);
+    }
+}
+
+TEST_CASE("Calling point_feature_builder::set_point() throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const assert_error&);
+}
+
+TEST_CASE("Calling add_points() and then other geometry functions throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_points(2);
+
+    SECTION("add_point()") {
+        REQUIRE_THROWS_AS(fbuilder.add_point(10, 20), const assert_error&);
+    }
+    SECTION("add_points()") {
+        REQUIRE_THROWS_AS(fbuilder.add_points(2), const assert_error&);
+    }
+}
+
+TEST_CASE("Calling point_feature_builder::set_point() too often throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_points(2);
+    fbuilder.set_point(10, 20);
+    fbuilder.set_point(20, 20);
+    REQUIRE_THROWS_AS(fbuilder.set_point(30, 20), const assert_error&);
+}
+
+TEST_CASE("Add points from container") {
+    const std::vector<vtzero::point> points = {{10, 20}, {20, 30}, {30, 40}};
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::point_feature_builder fbuilder{lbuilder};
+
+/*        SECTION("using iterators") {
+            fbuilder.add_points(points.cbegin(), points.cend());
+        }
+
+        SECTION("using iterators and size") {
+            fbuilder.add_points(points.cbegin(), points.cend(), static_cast<uint32_t>(points.size()));
+        }*/
+
+        SECTION("using container directly") {
+            fbuilder.add_points_from_container(points);
+        }
+
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+
+    point_handler handler;
+    vtzero::decode_point_geometry(feature.geometry(), handler);
+
+    REQUIRE(handler.data == points);
+}
+/*
+TEST_CASE("Add points from iterator with wrong count throws assert") {
+    const std::vector<vtzero::point> points = {{10, 20}, {20, 30}, {30, 40}};
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::point_feature_builder fbuilder{lbuilder};
+
+    REQUIRE_THROWS_AS(fbuilder.add_points(points.cbegin(),
+                                          points.cend(),
+                                          static_cast<uint32_t>(points.size() + 1)), const assert_error&);
+}*/
+
diff --git a/third_party/vtzero/test/t/test_builder_polygon.cpp b/third_party/vtzero/test/t/test_builder_polygon.cpp
new file mode 100644
index 00000000000..af05f5df388
--- /dev/null
+++ b/third_party/vtzero/test/t/test_builder_polygon.cpp
@@ -0,0 +1,307 @@
+
+#include <test.hpp>
+
+#include <vtzero/builder.hpp>
+#include <vtzero/geometry.hpp>
+#include <vtzero/index.hpp>
+
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+using polygon_type = std::vector<std::vector<vtzero::point>>;
+
+struct polygon_handler {
+
+    polygon_type data;
+
+    void ring_begin(uint32_t count) {
+        data.emplace_back();
+        data.back().reserve(count);
+    }
+
+    void ring_point(const vtzero::point point) {
+        data.back().push_back(point);
+    }
+
+    void ring_end(vtzero::ring_type /* type */) const noexcept {
+    }
+
+};
+
+static void test_polygon_builder(bool with_id, bool with_prop) {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+        if (with_id) {
+            fbuilder.set_id(17);
+        }
+
+        fbuilder.add_ring(4);
+        fbuilder.set_point(10, 20);
+        fbuilder.set_point(vtzero::point{20, 30});
+        fbuilder.set_point(mypoint{30, 40});
+        fbuilder.set_point(10, 20);
+
+        if (with_prop) {
+            fbuilder.add_property("foo", "bar");
+        }
+
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.id() == (with_id ? 17 : 0));
+
+    polygon_handler handler;
+    vtzero::decode_polygon_geometry(feature.geometry(), handler);
+
+    const polygon_type result = {{{10, 20}, {20, 30}, {30, 40}, {10, 20}}};
+    REQUIRE(handler.data == result);
+}
+
+TEST_CASE("polygon builder without id/without properties") {
+    test_polygon_builder(false, false);
+}
+
+TEST_CASE("polygon builder without id/with properties") {
+    test_polygon_builder(false, true);
+}
+
+TEST_CASE("polygon builder with id/without properties") {
+    test_polygon_builder(true, false);
+}
+
+TEST_CASE("polygon builder with id/with properties") {
+    test_polygon_builder(true, true);
+}
+
+TEST_CASE("Calling add_ring() with bad values throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    SECTION("0") {
+        REQUIRE_THROWS_AS(fbuilder.add_ring(0), const assert_error&);
+    }
+    SECTION("1") {
+        REQUIRE_THROWS_AS(fbuilder.add_ring(1), const assert_error&);
+    }
+    SECTION("2") {
+        REQUIRE_THROWS_AS(fbuilder.add_ring(2), const assert_error&);
+    }
+    SECTION("3") {
+        REQUIRE_THROWS_AS(fbuilder.add_ring(3), const assert_error&);
+    }
+    SECTION("2^29") {
+        REQUIRE_THROWS_AS(fbuilder.add_ring(1ul << 29u), const assert_error&);
+    }
+}
+
+static void test_multipolygon_builder(bool with_id, bool with_prop) {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    if (with_id) {
+        fbuilder.set_id(17);
+    }
+
+    fbuilder.add_ring(4);
+    fbuilder.set_point(10, 20);
+    fbuilder.set_point(vtzero::point{20, 30});
+    fbuilder.set_point(mypoint{30, 40});
+    fbuilder.set_point(10, 20);
+
+    fbuilder.add_ring(5);
+    fbuilder.set_point(1, 1);
+    fbuilder.set_point(2, 1);
+    fbuilder.set_point(2, 2);
+    fbuilder.set_point(1, 2);
+
+    if (with_id) {
+        fbuilder.set_point(1, 1);
+    } else {
+        fbuilder.close_ring();
+    }
+
+    if (with_prop) {
+        fbuilder.add_property("foo", vtzero::encoded_property_value{"bar"});
+    }
+
+    fbuilder.commit();
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.id() == (with_id ? 17 : 0));
+
+    polygon_handler handler;
+    vtzero::decode_polygon_geometry(feature.geometry(), handler);
+
+    const polygon_type result = {{{10, 20}, {20, 30}, {30, 40}, {10, 20}},
+                                 {{1, 1}, {2, 1}, {2, 2}, {1, 2}, {1, 1}}};
+    REQUIRE(handler.data == result);
+}
+
+
+TEST_CASE("Multipolygon builder without id/without properties") {
+    test_multipolygon_builder(false, false);
+}
+
+TEST_CASE("Multipolygon builder without id/with properties") {
+    test_multipolygon_builder(false, true);
+}
+
+TEST_CASE("Multipolygon builder with id/without properties") {
+    test_multipolygon_builder(true, false);
+}
+
+TEST_CASE("Multipolygon builder with id/with properties") {
+    test_multipolygon_builder(true, true);
+}
+
+TEST_CASE("Calling add_ring() twice throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_ring(4);
+    REQUIRE_ASSERT(fbuilder.add_ring(4));
+}
+
+TEST_CASE("Calling polygon_feature_builder::set_point()/close_ring() throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    SECTION("set_point") {
+        REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const assert_error&);
+    }
+    SECTION("close_ring") {
+        REQUIRE_THROWS_AS(fbuilder.close_ring(), const assert_error&);
+    }
+}
+
+TEST_CASE("Calling polygon_feature_builder::set_point()/close_ring() too often throws assert") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_ring(4);
+    fbuilder.set_point(10, 20);
+    fbuilder.set_point(20, 20);
+    fbuilder.set_point(30, 20);
+    fbuilder.set_point(10, 20);
+
+    SECTION("set_point") {
+        REQUIRE_THROWS_AS(fbuilder.set_point(50, 20), const assert_error&);
+    }
+    SECTION("close_ring") {
+        REQUIRE_THROWS_AS(fbuilder.close_ring(), const assert_error&);
+    }
+}
+
+TEST_CASE("Calling polygon_feature_builder::set_point() with same point throws") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_ring(4);
+    fbuilder.set_point(10, 10);
+    REQUIRE_THROWS_AS(fbuilder.set_point(10, 10), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("Calling polygon_feature_builder::set_point() creating unclosed ring throws") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    fbuilder.add_ring(4);
+    fbuilder.set_point(10, 10);
+    fbuilder.set_point(10, 20);
+    fbuilder.set_point(20, 20);
+    REQUIRE_THROWS_AS(fbuilder.set_point(20, 30), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("Add polygon from container") {
+    const polygon_type points = {{{10, 20}, {20, 30}, {30, 40}, {10, 20}}};
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    {
+        vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+#if 0
+        SECTION("using iterators") {
+            fbuilder.add_ring(points[0].cbegin(), points[0].cend());
+        }
+
+        SECTION("using iterators and size") {
+            fbuilder.add_ring(points[0].cbegin(), points[0].cend(), static_cast<uint32_t>(points[0].size()));
+        }
+#endif
+
+        SECTION("using container directly") {
+            fbuilder.add_ring_from_container(points[0]);
+        }
+
+        fbuilder.commit();
+    }
+
+    const std::string data = tbuilder.serialize();
+
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.next_layer();
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "test");
+    REQUIRE(layer.version() == 2);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+
+    polygon_handler handler;
+    vtzero::decode_polygon_geometry(feature.geometry(), handler);
+
+    REQUIRE(handler.data == points);
+}
+
+#if 0
+TEST_CASE("Add polygon from iterator with wrong count throws assert") {
+    const std::vector<vtzero::point> points = {{10, 20}, {20, 30}, {30, 40}, {10, 20}};
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::polygon_feature_builder fbuilder{lbuilder};
+
+    REQUIRE_THROWS_AS(fbuilder.add_ring(points.cbegin(),
+                                        points.cend(),
+                                        static_cast<uint32_t>(points.size() + 1)), const assert_error&);
+}
+#endif
+
diff --git a/third_party/vtzero/test/t/test_exceptions.cpp b/third_party/vtzero/test/t/test_exceptions.cpp
new file mode 100644
index 00000000000..7e5c6917acc
--- /dev/null
+++ b/third_party/vtzero/test/t/test_exceptions.cpp
@@ -0,0 +1,42 @@
+
+#include <test.hpp>
+
+#include <vtzero/exception.hpp>
+
+#include <string>
+
+TEST_CASE("construct format_exception with const char*") {
+    vtzero::format_exception e{"broken"};
+    REQUIRE(std::string{e.what()} == "broken");
+}
+
+TEST_CASE("construct format_exception with const std::string") {
+    vtzero::format_exception e{std::string{"broken"}};
+    REQUIRE(std::string{e.what()} == "broken");
+}
+
+TEST_CASE("construct geometry_exception with const char*") {
+    vtzero::geometry_exception e{"broken"};
+    REQUIRE(std::string{e.what()} == "broken");
+}
+
+TEST_CASE("construct geometry_exception with std::string") {
+    vtzero::geometry_exception e{std::string{"broken"}};
+    REQUIRE(std::string{e.what()} == "broken");
+}
+
+TEST_CASE("construct type_exception") {
+    vtzero::type_exception e;
+    REQUIRE(std::string{e.what()} == "wrong property value type");
+}
+
+TEST_CASE("construct version_exception") {
+    vtzero::version_exception e{42};
+    REQUIRE(std::string{e.what()} == "unknown vector tile version: 42");
+}
+
+TEST_CASE("construct out_of_range_exception") {
+    vtzero::out_of_range_exception e{99};
+    REQUIRE(std::string{e.what()} == "index out of range: 99");
+}
+
diff --git a/third_party/vtzero/test/t/test_feature.cpp b/third_party/vtzero/test/t/test_feature.cpp
new file mode 100644
index 00000000000..c3061b83f37
--- /dev/null
+++ b/third_party/vtzero/test/t/test_feature.cpp
@@ -0,0 +1,97 @@
+
+#include <test.hpp>
+
+#include <vtzero/feature.hpp>
+#include <vtzero/layer.hpp>
+#include <vtzero/vector_tile.hpp>
+
+TEST_CASE("default constructed feature") {
+    vtzero::feature feature{};
+
+    REQUIRE_FALSE(feature.valid());
+    REQUIRE_FALSE(feature);
+    REQUIRE(feature.id() == 0);
+    REQUIRE_FALSE(feature.has_id());
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::UNKNOWN);
+    REQUIRE_ASSERT(feature.geometry());
+    REQUIRE(feature.empty());
+    REQUIRE(feature.num_properties() == 0);
+}
+
+TEST_CASE("read a feature") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.get_layer_by_name("bridge");
+    REQUIRE(layer.valid());
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.valid());
+    REQUIRE(feature);
+    REQUIRE(feature.id() == 0);
+    REQUIRE(feature.has_id());
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::LINESTRING);
+    REQUIRE_FALSE(feature.empty());
+    REQUIRE(feature.num_properties() == 4);
+}
+
+TEST_CASE("iterate over all properties of a feature") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+    auto layer = tile.get_layer_by_name("bridge");
+    auto feature = layer.next_feature();
+
+    int count = 0;
+    SECTION("external iterator") {
+        while (auto p = feature.next_property()) {
+            ++count;
+            if (p.key() == "type") {
+                REQUIRE(p.value().type() == vtzero::property_value_type::string_value);
+                REQUIRE(p.value().string_value() == "primary");
+            }
+        }
+    }
+
+    SECTION("internal iterator") {
+        feature.for_each_property([&count](const vtzero::property& p) {
+            ++count;
+            if (p.key() == "type") {
+                REQUIRE(p.value().type() == vtzero::property_value_type::string_value);
+                REQUIRE(p.value().string_value() == "primary");
+            }
+            return true;
+        });
+    }
+
+    REQUIRE(count == 4);
+}
+
+TEST_CASE("iterate over some properties of a feature") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+    auto layer = tile.get_layer_by_name("bridge");
+    REQUIRE(layer.valid());
+
+    auto feature = layer.next_feature();
+    REQUIRE(feature.valid());
+
+    int count = 0;
+    SECTION("external iterator") {
+        while (auto p = feature.next_property()) {
+            ++count;
+            if (p.key() == "oneway") {
+                break;
+            }
+        }
+    }
+
+    SECTION("internal iterator") {
+        feature.for_each_property([&count](const vtzero::property& p) {
+            ++count;
+            return p.key() != "oneway";
+        });
+    }
+
+    REQUIRE(count == 2);
+}
+
diff --git a/third_party/vtzero/test/t/test_geometry.cpp b/third_party/vtzero/test/t/test_geometry.cpp
new file mode 100644
index 00000000000..7462599ec30
--- /dev/null
+++ b/third_party/vtzero/test/t/test_geometry.cpp
@@ -0,0 +1,334 @@
+
+#include <test.hpp>
+
+#include <vtzero/geometry.hpp>
+
+#include <cstdint>
+#include <limits>
+#include <vector>
+
+using container = std::vector<uint32_t>;
+using iterator = container::const_iterator;
+
+TEST_CASE("geometry_decoder") {
+    const container g = {};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+
+    REQUIRE(decoder.count() == 0);
+    REQUIRE(decoder.done());
+    REQUIRE_FALSE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE_THROWS_AS(decoder.next_point(), const assert_error&);
+}
+
+TEST_CASE("geometry_decoder with point") {
+    const container g = {9, 50, 34};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE_THROWS_AS(decoder.next_point(), const assert_error&);
+
+    SECTION("trying to get LineTo command") {
+        REQUIRE_THROWS_AS(decoder.next_command(vtzero::detail::CommandId::LINE_TO), const vtzero::geometry_exception&);
+    }
+
+    SECTION("trying to get ClosePath command") {
+        REQUIRE_THROWS_WITH(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH), "expected command 7 but got 1");
+    }
+
+    SECTION("trying to get MoveTo command") {
+        REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+        REQUIRE_THROWS_AS(decoder.next_command(vtzero::detail::CommandId::MOVE_TO), const assert_error&);
+        REQUIRE(decoder.count() == 1);
+        REQUIRE(decoder.next_point() == vtzero::point(25, 17));
+
+        REQUIRE(decoder.done());
+        REQUIRE_FALSE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    }
+}
+
+TEST_CASE("geometry_decoder with incomplete point") {
+    container g = {9, 50, 34};
+
+    SECTION("half a point") {
+        g.pop_back();
+    }
+
+    SECTION("missing point") {
+        g.pop_back();
+        g.pop_back();
+    }
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), 100};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE_THROWS_AS(decoder.next_point(), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("geometry_decoder with multipoint") {
+    const container g = {17, 10, 14, 3, 9};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(5, 7));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(3, 2));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.done());
+    REQUIRE_FALSE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+}
+
+TEST_CASE("geometry_decoder with linestring") {
+    const container g = {9, 4, 4, 18, 0, 16, 16, 0};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(2, 2));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(2, 10));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(10, 10));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.done());
+    REQUIRE_FALSE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+}
+
+TEST_CASE("geometry_decoder with linestring with equal points") {
+    const container g = {9, 4, 4, 18, 0, 16, 0, 0};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(2, 2));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(2, 10));
+    REQUIRE(decoder.count() == 1);
+
+    REQUIRE(decoder.next_point() == vtzero::point(2, 10));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.done());
+}
+
+TEST_CASE("geometry_decoder with multilinestring") {
+    const container g = {9, 4, 4, 18, 0, 16, 16, 0, 9, 17, 17, 10, 4, 8};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(2, 2));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(2, 10));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(10, 10));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(1, 1));
+    REQUIRE(decoder.count() == 0);
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(3, 5));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.done());
+    REQUIRE_FALSE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+}
+
+TEST_CASE("geometry_decoder with polygon") {
+    const container g = {9, 6, 12, 18, 10, 12, 24, 44, 15};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(3, 6));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(8, 12));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(20, 34));
+    REQUIRE(decoder.count() == 0);
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.done());
+    REQUIRE_FALSE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+}
+
+TEST_CASE("geometry_decoder with polygon with wrong ClosePath count 2") {
+    const container g = {9, 6, 12, 18, 10, 12, 24, 44, 23};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.next_point() == vtzero::point(3, 6));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.next_point() == vtzero::point(8, 12));
+    REQUIRE(decoder.next_point() == vtzero::point(20, 34));
+    REQUIRE_THROWS_AS(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH), "ClosePath command count is not 1");
+}
+
+TEST_CASE("geometry_decoder with polygon with wrong ClosePath count 0") {
+    const container g = {9, 6, 12, 18, 10, 12, 24, 44, 7};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.next_point() == vtzero::point(3, 6));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.next_point() == vtzero::point(8, 12));
+    REQUIRE(decoder.next_point() == vtzero::point(20, 34));
+    REQUIRE_THROWS_AS(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH), const vtzero::geometry_exception&);
+    REQUIRE_THROWS_WITH(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH), "ClosePath command count is not 1");
+}
+
+TEST_CASE("geometry_decoder with multipolygon") {
+    const container g = {9, 0, 0, 26, 20, 0, 0, 20, 19, 0, 15, 9, 22, 2, 26, 18,
+                         0, 0, 18, 17, 0, 15, 9, 4, 13, 26, 0, 8, 8, 0, 0, 7, 15};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(0, 0));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 3);
+    REQUIRE(decoder.next_point() == vtzero::point(10, 0));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(10, 10));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(0, 10));
+    REQUIRE(decoder.count() == 0);
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(11, 11));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 3);
+    REQUIRE(decoder.next_point() == vtzero::point(20, 11));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(20, 20));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(11, 20));
+    REQUIRE(decoder.count() == 0);
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(13, 13));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 3);
+    REQUIRE(decoder.next_point() == vtzero::point(13, 17));
+    REQUIRE(decoder.count() == 2);
+    REQUIRE(decoder.next_point() == vtzero::point(17, 17));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(17, 13));
+    REQUIRE(decoder.count() == 0);
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::CLOSE_PATH));
+    REQUIRE(decoder.count() == 0);
+
+    REQUIRE(decoder.done());
+    REQUIRE_FALSE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+}
+
+TEST_CASE("geometry_decoder decoding linestring with int32 overflow in x coordinate") {
+    const container g = {vtzero::detail::command_move_to(1),
+                           protozero::encode_zigzag32(std::numeric_limits<int32_t>::max()),
+                           protozero::encode_zigzag32(0),
+                         vtzero::detail::command_line_to(1),
+                           protozero::encode_zigzag32(1),
+                           protozero::encode_zigzag32(1)
+                         };
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(std::numeric_limits<int32_t>::max(), 0));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(std::numeric_limits<int32_t>::min(), 1));
+}
+
+TEST_CASE("geometry_decoder decoding linestring with int32 overflow in y coordinate") {
+    const container g = {vtzero::detail::command_move_to(1),
+                           protozero::encode_zigzag32(0),
+                           protozero::encode_zigzag32(std::numeric_limits<int32_t>::min()),
+                         vtzero::detail::command_line_to(1),
+                           protozero::encode_zigzag32(-1),
+                           protozero::encode_zigzag32(-1)
+                         };
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::MOVE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(0, std::numeric_limits<int32_t>::min()));
+    REQUIRE(decoder.next_command(vtzero::detail::CommandId::LINE_TO));
+    REQUIRE(decoder.count() == 1);
+    REQUIRE(decoder.next_point() == vtzero::point(-1, std::numeric_limits<int32_t>::max()));
+}
+
+TEST_CASE("geometry_decoder with multipoint with a huge count") {
+    const uint32_t huge_value = (1ul << 29u) - 1;
+    const container g = {vtzero::detail::command_move_to(huge_value), 10, 10};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), g.size() / 2};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE_THROWS_AS(decoder.next_command(vtzero::detail::CommandId::MOVE_TO), const vtzero::geometry_exception&);
+}
+
+TEST_CASE("geometry_decoder with multipoint with not enough points") {
+    const container g = {vtzero::detail::command_move_to(2), 10};
+
+    vtzero::detail::geometry_decoder<iterator> decoder{g.cbegin(), g.cend(), 1};
+    REQUIRE(decoder.count() == 0);
+    REQUIRE_FALSE(decoder.done());
+
+    REQUIRE_THROWS_AS(decoder.next_command(vtzero::detail::CommandId::MOVE_TO), const vtzero::geometry_exception&);
+}
+
diff --git a/third_party/vtzero/test/t/test_geometry_linestring.cpp b/third_party/vtzero/test/t/test_geometry_linestring.cpp
new file mode 100644
index 00000000000..36fc5eedb16
--- /dev/null
+++ b/third_party/vtzero/test/t/test_geometry_linestring.cpp
@@ -0,0 +1,160 @@
+
+#include <test.hpp>
+
+#include <vtzero/geometry.hpp>
+
+#include <cstdint>
+#include <vector>
+
+using container = std::vector<uint32_t>;
+using iterator = container::const_iterator;
+
+class dummy_geom_handler {
+
+    int value = 0;
+
+public:
+
+    void linestring_begin(const uint32_t /*count*/) noexcept {
+        ++value;
+    }
+
+    void linestring_point(const vtzero::point /*point*/) noexcept {
+        value += 100;
+    }
+
+    void linestring_end() noexcept {
+        value += 10000;
+    }
+
+    int result() const noexcept {
+        return value;
+    }
+
+}; // class dummy_geom_handler
+
+TEST_CASE("Calling decode_linestring_geometry() with empty input") {
+    const container g;
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    dummy_geom_handler handler;
+    decoder.decode_linestring(dummy_geom_handler{});
+    REQUIRE(handler.result() == 0);
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with a valid linestring") {
+    const container g = {9, 4, 4, 18, 0, 16, 16, 0};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    REQUIRE(decoder.decode_linestring(dummy_geom_handler{}) == 10301);
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with a valid multilinestring") {
+    const container g = {9, 4, 4, 18, 0, 16, 16, 0, 9, 17, 17, 10, 4, 8};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    dummy_geom_handler handler;
+    decoder.decode_linestring(handler);
+    REQUIRE(handler.result() == 20502);
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with a point geometry fails") {
+    const container g = {9, 50, 34}; // this is a point geometry
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_linestring(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_linestring(dummy_geom_handler{}),
+                            "expected LineTo command (spec 4.3.4.3)");
+    }
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with a polygon geometry fails") {
+    const container g = {9, 6, 12, 18, 10, 12, 24, 44, 15}; // this is a polygon geometry
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_linestring(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_linestring(dummy_geom_handler{}),
+                            "expected command 1 but got 7");
+    }
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with something other than MoveTo command") {
+    const container g = {vtzero::detail::command_line_to(3)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_linestring(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_linestring(dummy_geom_handler{}),
+                            "expected command 1 but got 2");
+    }
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with a count of 0") {
+    const container g = {vtzero::detail::command_move_to(0)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_linestring(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_linestring(dummy_geom_handler{}),
+                            "MoveTo command count is not 1 (spec 4.3.4.3)");
+    }
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with a count of 2") {
+    const container g = {vtzero::detail::command_move_to(2), 10, 20, 20, 10};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_linestring(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_linestring(dummy_geom_handler{}),
+                            "MoveTo command count is not 1 (spec 4.3.4.3)");
+    }
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with 2nd command not a LineTo") {
+    const container g = {vtzero::detail::command_move_to(1), 3, 4,
+                         vtzero::detail::command_move_to(1)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_linestring(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_linestring(dummy_geom_handler{}),
+                            "expected command 2 but got 1");
+    }
+}
+
+TEST_CASE("Calling decode_linestring_geometry() with LineTo and 0 count") {
+    const container g = {vtzero::detail::command_move_to(1), 3, 4,
+                         vtzero::detail::command_line_to(0)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_linestring(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_linestring(dummy_geom_handler{}),
+                            "LineTo command count is zero (spec 4.3.4.3)");
+    }
+}
+
diff --git a/third_party/vtzero/test/t/test_geometry_point.cpp b/third_party/vtzero/test/t/test_geometry_point.cpp
new file mode 100644
index 00000000000..b8e4480dfc4
--- /dev/null
+++ b/third_party/vtzero/test/t/test_geometry_point.cpp
@@ -0,0 +1,135 @@
+
+#include <test.hpp>
+
+#include <vtzero/geometry.hpp>
+
+#include <cstdint>
+#include <vector>
+
+using container = std::vector<uint32_t>;
+using iterator = container::const_iterator;
+
+class dummy_geom_handler {
+
+    int value = 0;
+
+public:
+
+    void points_begin(const uint32_t /*count*/) noexcept {
+        ++value;
+    }
+
+    void points_point(const vtzero::point /*point*/) noexcept {
+        value += 100;
+    }
+
+    void points_end() noexcept {
+        value += 10000;
+    }
+
+    int result() const noexcept {
+        return value;
+    }
+
+}; // class dummy_geom_handler
+
+TEST_CASE("Calling decode_point() with empty input") {
+    const container g;
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_point(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_point(dummy_geom_handler{}),
+                            "expected MoveTo command (spec 4.3.4.2)");
+    }
+}
+
+TEST_CASE("Calling decode_point() with a valid point") {
+    const container g = {9, 50, 34};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    dummy_geom_handler handler;
+    decoder.decode_point(handler);
+    REQUIRE(handler.result() == 10101);
+}
+
+TEST_CASE("Calling decode_point() with a valid multipoint") {
+    const container g = {17, 10, 14, 3, 9};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    REQUIRE(decoder.decode_point(dummy_geom_handler{}) == 10201);
+}
+
+TEST_CASE("Calling decode_point() with a linestring geometry fails") {
+    const container g = {9, 4, 4, 18, 0, 16, 16, 0}; // this is a linestring geometry
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_point(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_point(dummy_geom_handler{}),
+                            "additional data after end of geometry (spec 4.3.4.2)");
+    }
+}
+
+TEST_CASE("Calling decode_point() with a polygon geometry fails") {
+    const container g = {9, 6, 12, 18, 10, 12, 24, 44, 15}; // this is a polygon geometry
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_point(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_point(dummy_geom_handler{}),
+                            "additional data after end of geometry (spec 4.3.4.2)");
+    }
+}
+
+TEST_CASE("Calling decode_point() with something other than MoveTo command") {
+    const container g = {vtzero::detail::command_line_to(3)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_point(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_point(dummy_geom_handler{}),
+                            "expected command 1 but got 2");
+    }
+}
+
+TEST_CASE("Calling decode_point() with a count of 0") {
+    const container g = {vtzero::detail::command_move_to(0)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_point(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_point(dummy_geom_handler{}),
+                            "MoveTo command count is zero (spec 4.3.4.2)");
+    }
+}
+
+TEST_CASE("Calling decode_point() with more data then expected") {
+    const container g = {9, 50, 34, 9};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_point(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_point(dummy_geom_handler{}),
+                            "additional data after end of geometry (spec 4.3.4.2)");
+    }
+}
+
diff --git a/third_party/vtzero/test/t/test_geometry_polygon.cpp b/third_party/vtzero/test/t/test_geometry_polygon.cpp
new file mode 100644
index 00000000000..c85de30179e
--- /dev/null
+++ b/third_party/vtzero/test/t/test_geometry_polygon.cpp
@@ -0,0 +1,204 @@
+
+#include <test.hpp>
+
+#include <vtzero/geometry.hpp>
+
+#include <cstdint>
+#include <vector>
+
+using container = std::vector<uint32_t>;
+using iterator = container::const_iterator;
+
+class dummy_geom_handler {
+
+    int value = 0;
+
+public:
+
+    void ring_begin(const uint32_t /*count*/) noexcept {
+        ++value;
+    }
+
+    void ring_point(const vtzero::point /*point*/) noexcept {
+        value += 100;
+    }
+
+    void ring_end(vtzero::ring_type /*is_outer*/) noexcept {
+        value += 10000;
+    }
+
+    int result() const noexcept {
+        return value;
+    }
+
+}; // class dummy_geom_handler
+
+TEST_CASE("Calling decode_polygon_geometry() with empty input") {
+    const container g;
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    dummy_geom_handler handler;
+    decoder.decode_polygon(dummy_geom_handler{});
+    REQUIRE(handler.result() == 0);
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with a valid polygon") {
+    const container g = {9, 6, 12, 18, 10, 12, 24, 44, 15};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    REQUIRE(decoder.decode_polygon(dummy_geom_handler{}) == 10401);
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with a duplicate end point") {
+    const container g = {9, 6, 12, 26, 10, 12, 24, 44, 33, 55, 15};
+
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+    dummy_geom_handler handler;
+    decoder.decode_polygon(handler);
+    REQUIRE(handler.result() == 10501);
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with a valid multipolygon") {
+    const container g = {9, 0, 0, 26, 20, 0, 0, 20, 19, 0, 15, 9, 22, 2, 26, 18,
+                         0, 0, 18, 17, 0, 15, 9, 4, 13, 26, 0, 8, 8, 0, 0, 7, 15};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    dummy_geom_handler handler;
+    decoder.decode_polygon(handler);
+    REQUIRE(handler.result() == 31503);
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with a point geometry fails") {
+    const container g = {9, 50, 34}; // this is a point geometry
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_polygon(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_polygon(dummy_geom_handler{}),
+                            "expected LineTo command (spec 4.3.4.4)");
+    }
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with a linestring geometry fails") {
+    const container g = {9, 4, 4, 18, 0, 16, 16, 0}; // this is a linestring geometry
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_polygon(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_polygon(dummy_geom_handler{}),
+                            "expected ClosePath command (4.3.4.4)");
+    }
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with something other than MoveTo command") {
+    const container g = {vtzero::detail::command_line_to(3)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_polygon(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_polygon(dummy_geom_handler{}),
+                            "expected command 1 but got 2");
+    }
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with a count of 0") {
+    const container g = {vtzero::detail::command_move_to(0)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_polygon(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_polygon(dummy_geom_handler{}),
+                            "MoveTo command count is not 1 (spec 4.3.4.4)");
+    }
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with a count of 2") {
+    const container g = {vtzero::detail::command_move_to(2), 1, 2, 3, 4};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_polygon(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_polygon(dummy_geom_handler{}),
+                            "MoveTo command count is not 1 (spec 4.3.4.4)");
+    }
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with 2nd command not a LineTo") {
+    const container g = {vtzero::detail::command_move_to(1), 3, 4,
+                         vtzero::detail::command_move_to(1)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_polygon(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_polygon(dummy_geom_handler{}),
+                            "expected command 2 but got 1");
+    }
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with LineTo and 0 count") {
+    const container g = {vtzero::detail::command_move_to(1), 3, 4,
+                         vtzero::detail::command_line_to(0),
+                         vtzero::detail::command_close_path()};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    dummy_geom_handler handler;
+    decoder.decode_polygon(handler);
+    REQUIRE(handler.result() == 10201);
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with LineTo and 1 count") {
+    const container g = {vtzero::detail::command_move_to(1), 3, 4,
+                         vtzero::detail::command_line_to(1), 5, 6,
+                         vtzero::detail::command_close_path()};
+
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+    dummy_geom_handler handler;
+    decoder.decode_polygon(handler);
+    REQUIRE(handler.result() == 10301);
+}
+
+TEST_CASE("Calling decode_polygon_geometry() with 3nd command not a ClosePath") {
+    const container g = {vtzero::detail::command_move_to(1), 3, 4,
+                         vtzero::detail::command_line_to(2), 4, 5, 6, 7,
+                         vtzero::detail::command_line_to(0)};
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+
+    SECTION("check exception type") {
+        REQUIRE_THROWS_AS(decoder.decode_polygon(dummy_geom_handler{}),
+                          const vtzero::geometry_exception&);
+    }
+    SECTION("check exception message") {
+        REQUIRE_THROWS_WITH(decoder.decode_polygon(dummy_geom_handler{}),
+                            "expected command 7 but got 2");
+    }
+}
+
+TEST_CASE("Calling decode_polygon_geometry() on polygon with zero area") {
+    const container g = {vtzero::detail::command_move_to(1), 0, 0,
+                         vtzero::detail::command_line_to(3), 2, 0, 0, 4, 2, 0,
+                         vtzero::detail::command_close_path()};
+
+    vtzero::detail::geometry_decoder<container::const_iterator> decoder{g.begin(), g.end(), g.size() / 2};
+    dummy_geom_handler handler;
+    decoder.decode_polygon(handler);
+    REQUIRE(handler.result() == 10501);
+}
+
diff --git a/third_party/vtzero/test/t/test_index.cpp b/third_party/vtzero/test/t/test_index.cpp
new file mode 100644
index 00000000000..cf7e1962432
--- /dev/null
+++ b/third_party/vtzero/test/t/test_index.cpp
@@ -0,0 +1,343 @@
+
+#include <test.hpp>
+
+#include <vtzero/builder.hpp>
+#include <vtzero/index.hpp>
+
+#include <map>
+#include <string>
+#include <unordered_map>
+
+TEST_CASE("add keys to layer using key index built into layer") {
+    static constexpr const int max_keys = 100;
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    for (int n = 0; n < max_keys; ++n) {
+        const auto key = std::to_string(n);
+        const auto idx = lbuilder.add_key(key);
+        REQUIRE(n == idx.value());
+    }
+
+    for (int n = 0; n < max_keys; n += 2) {
+        const auto key = std::to_string(n);
+        const auto idx = lbuilder.add_key(key);
+        REQUIRE(n == idx.value());
+    }
+}
+
+TEST_CASE("add values to layer using value index built into layer") {
+    static constexpr const int max_values = 100;
+
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    for (int n = 0; n < max_values; ++n) {
+        const auto value = std::to_string(n);
+        const auto idx = lbuilder.add_value(vtzero::encoded_property_value{value});
+        REQUIRE(n == idx.value());
+    }
+
+    for (int n = 0; n < max_values; n += 2) {
+        const auto value = std::to_string(n);
+        const auto idx = lbuilder.add_value(vtzero::encoded_property_value{value});
+        REQUIRE(n == idx.value());
+    }
+}
+
+template <typename TIndex>
+static void test_key_index() {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    TIndex index{lbuilder};
+
+    const auto i1 = index({"foo"});
+    const auto i2 = index({"bar"});
+    const auto i3 = index({"baz"});
+    const auto i4 = index({"foo"});
+    const auto i5 = index({"foo"});
+    const auto i6 = index({""});
+    const auto i7 = index({"bar"});
+
+    REQUIRE(i1 != i2);
+    REQUIRE(i1 != i3);
+    REQUIRE(i1 == i4);
+    REQUIRE(i1 == i5);
+    REQUIRE(i1 != i6);
+    REQUIRE(i1 != i7);
+    REQUIRE(i2 != i3);
+    REQUIRE(i2 != i4);
+    REQUIRE(i2 != i5);
+    REQUIRE(i2 != i6);
+    REQUIRE(i2 == i7);
+    REQUIRE(i3 != i4);
+    REQUIRE(i3 != i5);
+    REQUIRE(i3 != i6);
+    REQUIRE(i3 != i7);
+    REQUIRE(i4 == i5);
+    REQUIRE(i4 != i6);
+    REQUIRE(i4 != i7);
+    REQUIRE(i5 != i6);
+    REQUIRE(i5 != i7);
+    REQUIRE(i6 != i7);
+}
+
+TEST_CASE("key index based on std::unordered_map") {
+    test_key_index<vtzero::key_index<std::unordered_map>>();
+}
+
+TEST_CASE("key index based on std::map") {
+    test_key_index<vtzero::key_index<std::map>>();
+}
+
+template <typename TIndex>
+static void test_value_index_internal() {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    TIndex index{lbuilder};
+
+    const auto i1 = index(vtzero::encoded_property_value{"foo"});
+    const auto i2 = index(vtzero::encoded_property_value{"bar"});
+    const auto i3 = index(vtzero::encoded_property_value{88});
+    const auto i4 = index(vtzero::encoded_property_value{"foo"});
+    const auto i5 = index(vtzero::encoded_property_value{77});
+    const auto i6 = index(vtzero::encoded_property_value{1.5});
+    const auto i7 = index(vtzero::encoded_property_value{"bar"});
+
+    REQUIRE(i1 != i2);
+    REQUIRE(i1 != i3);
+    REQUIRE(i1 == i4);
+    REQUIRE(i1 != i5);
+    REQUIRE(i1 != i6);
+    REQUIRE(i1 != i7);
+
+    REQUIRE(i2 != i3);
+    REQUIRE(i2 != i4);
+    REQUIRE(i2 != i5);
+    REQUIRE(i2 != i6);
+    REQUIRE(i2 == i7);
+
+    REQUIRE(i3 != i4);
+    REQUIRE(i3 != i5);
+    REQUIRE(i3 != i6);
+    REQUIRE(i3 != i7);
+
+    REQUIRE(i4 != i5);
+    REQUIRE(i4 != i6);
+    REQUIRE(i4 != i7);
+
+    REQUIRE(i5 != i6);
+    REQUIRE(i5 != i7);
+
+    REQUIRE(i6 != i7);
+}
+
+TEST_CASE("internal value index based on std::unordered_map") {
+    test_value_index_internal<vtzero::value_index_internal<std::unordered_map>>();
+}
+
+TEST_CASE("internal value index based on std::map") {
+    test_value_index_internal<vtzero::value_index_internal<std::map>>();
+}
+
+TEST_CASE("external value index") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    vtzero::value_index<vtzero::string_value_type, std::string, std::map> string_index{lbuilder};
+    vtzero::value_index<vtzero::int_value_type, int, std::unordered_map> int_index{lbuilder};
+    vtzero::value_index<vtzero::sint_value_type, int, std::unordered_map> sint_index{lbuilder};
+
+    const auto i1 = string_index("foo");
+    const auto i2 = string_index("bar");
+    const auto i3 = int_index(6);
+    const auto i4 = sint_index(6);
+    const auto i5 = string_index(std::string{"foo"});
+    const auto i6 = int_index(6);
+    const auto i7 = sint_index(2);
+    const auto i8 = sint_index(5);
+    const auto i9 = sint_index(6);
+
+    REQUIRE(i1 != i2);
+    REQUIRE(i1 != i3);
+    REQUIRE(i1 != i4);
+    REQUIRE(i1 == i5);
+    REQUIRE(i1 != i6);
+    REQUIRE(i1 != i7);
+    REQUIRE(i1 != i7);
+    REQUIRE(i1 != i9);
+
+    REQUIRE(i2 != i3);
+    REQUIRE(i2 != i4);
+    REQUIRE(i2 != i5);
+    REQUIRE(i2 != i6);
+    REQUIRE(i2 != i7);
+    REQUIRE(i2 != i8);
+    REQUIRE(i2 != i9);
+
+    REQUIRE(i3 != i4);
+    REQUIRE(i3 != i5);
+    REQUIRE(i3 == i6);
+    REQUIRE(i3 != i7);
+    REQUIRE(i3 != i8);
+    REQUIRE(i3 != i9);
+
+    REQUIRE(i4 != i5);
+    REQUIRE(i4 != i6);
+    REQUIRE(i4 != i7);
+    REQUIRE(i4 != i8);
+    REQUIRE(i4 == i9);
+
+    REQUIRE(i5 != i6);
+    REQUIRE(i5 != i7);
+    REQUIRE(i5 != i8);
+    REQUIRE(i5 != i9);
+
+    REQUIRE(i6 != i7);
+    REQUIRE(i6 != i8);
+    REQUIRE(i6 != i9);
+
+    REQUIRE(i7 != i8);
+    REQUIRE(i7 != i9);
+
+    REQUIRE(i8 != i9);
+}
+
+TEST_CASE("bool value index") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::value_index_bool index{lbuilder};
+
+    const auto i1 = index(false);
+    const auto i2 = index(true);
+    const auto i3 = index(true);
+    const auto i4 = index(false);
+
+    REQUIRE(i1 != i2);
+    REQUIRE(i1 != i3);
+    REQUIRE(i1 == i4);
+
+    REQUIRE(i2 == i3);
+    REQUIRE(i2 != i4);
+
+    REQUIRE(i3 != i4);
+}
+
+TEST_CASE("small unsigned int value index") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    vtzero::value_index_small_uint index{lbuilder};
+
+    const auto i1 = index(12);
+    const auto i2 = index(4);
+    const auto i3 = index(0);
+    const auto i4 = index(100);
+    const auto i5 = index(4);
+    const auto i6 = index(12);
+
+    REQUIRE(i1 != i2);
+    REQUIRE(i1 != i3);
+    REQUIRE(i1 != i4);
+    REQUIRE(i1 != i5);
+    REQUIRE(i1 == i6);
+
+    REQUIRE(i2 != i3);
+    REQUIRE(i2 != i4);
+    REQUIRE(i2 == i5);
+    REQUIRE(i2 != i6);
+
+    REQUIRE(i3 != i4);
+    REQUIRE(i3 != i5);
+    REQUIRE(i3 != i6);
+
+    REQUIRE(i4 != i5);
+    REQUIRE(i4 != i6);
+
+    REQUIRE(i5 != i6);
+}
+
+TEST_CASE("add features using a key index") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+
+    vtzero::point_feature_builder fbuilder{lbuilder};
+    fbuilder.set_id(7);
+    fbuilder.add_point(10, 20);
+
+    SECTION("no index") {
+        fbuilder.add_property("some_key", 12);
+    }
+
+    SECTION("key index using unordered_map") {
+        vtzero::key_index<std::unordered_map> index{lbuilder};
+        fbuilder.add_property(index("some_key"), 12);
+    }
+
+    SECTION("key index using map") {
+        vtzero::key_index<std::map> index{lbuilder};
+        fbuilder.add_property(index("some_key"), 12);
+    }
+
+    fbuilder.commit();
+
+    const std::string data = tbuilder.serialize();
+
+    // ============
+
+    vtzero::vector_tile tile{data};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+    auto feature = layer.next_feature();
+    REQUIRE(feature.id() == 7);
+    const auto property = feature.next_property();
+    REQUIRE(property.value().int_value() == 12);
+}
+
+TEST_CASE("add features using a value index") {
+    vtzero::tile_builder tbuilder;
+    vtzero::layer_builder lbuilder{tbuilder, "test"};
+    const auto key = lbuilder.add_key("some_key");
+
+    vtzero::point_feature_builder fbuilder{lbuilder};
+    fbuilder.set_id(17);
+    fbuilder.add_point(10, 20);
+
+    SECTION("no index") {
+        fbuilder.add_property(key, vtzero::sint_value_type{12});
+    }
+
+    SECTION("external value index using unordered_map") {
+        vtzero::value_index<vtzero::sint_value_type, int, std::unordered_map> index{lbuilder};
+        fbuilder.add_property(key, index(12));
+    }
+
+    SECTION("external value index using map") {
+        vtzero::value_index<vtzero::sint_value_type, int, std::map> index{lbuilder};
+        fbuilder.add_property(key, index(12));
+    }
+
+    SECTION("property_value_type index") {
+        vtzero::value_index_internal<std::unordered_map> index{lbuilder};
+        fbuilder.add_property(key, index(vtzero::encoded_property_value{vtzero::sint_value_type{12}}));
+    }
+
+    fbuilder.commit();
+
+    const std::string data = tbuilder.serialize();
+
+    // ============
+
+    vtzero::vector_tile tile{data};
+
+    REQUIRE(tile.count_layers() == 1);
+    auto layer = tile.next_layer();
+    REQUIRE(layer.num_features() == 1);
+    auto feature = layer.next_feature();
+    REQUIRE(feature.id() == 17);
+    const auto property = feature.next_property();
+    REQUIRE(property.value().sint_value() == 12);
+}
+
diff --git a/third_party/vtzero/test/t/test_layer.cpp b/third_party/vtzero/test/t/test_layer.cpp
new file mode 100644
index 00000000000..cf5dd914322
--- /dev/null
+++ b/third_party/vtzero/test/t/test_layer.cpp
@@ -0,0 +1,155 @@
+
+#include <test.hpp>
+
+#include <vtzero/layer.hpp>
+#include <vtzero/vector_tile.hpp>
+
+#include <cstddef>
+
+TEST_CASE("default constructed layer") {
+    vtzero::layer layer{};
+    REQUIRE_FALSE(layer.valid());
+    REQUIRE_FALSE(layer);
+
+    REQUIRE(layer.data() == vtzero::data_view{});
+    REQUIRE_ASSERT(layer.version());
+    REQUIRE_ASSERT(layer.extent());
+    REQUIRE_ASSERT(layer.name());
+
+    REQUIRE(layer.empty());
+    REQUIRE(layer.num_features() == 0);
+
+    REQUIRE_THROWS_AS(layer.key_table(), const assert_error&);
+    REQUIRE_THROWS_AS(layer.value_table(), const assert_error&);
+
+    REQUIRE_THROWS_AS(layer.key(0), const assert_error&);
+    REQUIRE_THROWS_AS(layer.value(0), const assert_error&);
+
+    REQUIRE_THROWS_AS(layer.get_feature_by_id(0), const assert_error&);
+    REQUIRE_THROWS_AS(layer.next_feature(), const assert_error&);
+    REQUIRE_ASSERT(layer.reset_feature());
+}
+
+TEST_CASE("read a layer") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.get_layer_by_name("bridge");
+    REQUIRE(layer.valid());
+    REQUIRE(layer);
+
+    REQUIRE(layer.version() == 1);
+    REQUIRE(layer.extent() == 4096);
+    REQUIRE(layer.name() == "bridge");
+
+    REQUIRE_FALSE(layer.empty());
+    REQUIRE(layer.num_features() == 2);
+
+    const auto& kt = layer.key_table();
+    REQUIRE(kt.size() == 4);
+    REQUIRE(kt[0] == "class");
+
+    const auto& vt = layer.value_table();
+    REQUIRE(vt.size() == 4);
+    REQUIRE(vt[0].type() == vtzero::property_value_type::string_value);
+    REQUIRE(vt[0].string_value() == "main");
+    REQUIRE(vt[1].type() == vtzero::property_value_type::int_value);
+    REQUIRE(vt[1].int_value() == 0);
+
+    REQUIRE(layer.key(0) == "class");
+    REQUIRE(layer.key(1) == "oneway");
+    REQUIRE(layer.key(2) == "osm_id");
+    REQUIRE(layer.key(3) == "type");
+    REQUIRE_THROWS_AS(layer.key(4), const vtzero::out_of_range_exception&);
+
+    REQUIRE(layer.value(0).string_value() == "main");
+    REQUIRE(layer.value(1).int_value() == 0);
+    REQUIRE(layer.value(2).string_value() == "primary");
+    REQUIRE(layer.value(3).string_value() == "tertiary");
+    REQUIRE_THROWS_AS(layer.value(4), const vtzero::out_of_range_exception&);
+}
+
+TEST_CASE("access features in a layer by id") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.get_layer_by_name("building");
+    REQUIRE(layer);
+
+    REQUIRE(layer.num_features() == 937);
+
+    const auto feature = layer.get_feature_by_id(122);
+    REQUIRE(feature.id() == 122);
+    REQUIRE(feature.num_properties() == 0);
+    REQUIRE(feature.geometry_type() == vtzero::GeomType::POLYGON);
+    REQUIRE(feature.geometry().type() == vtzero::GeomType::POLYGON);
+    REQUIRE_FALSE(feature.geometry().data().empty());
+
+    REQUIRE_FALSE(layer.get_feature_by_id(844));
+    REQUIRE_FALSE(layer.get_feature_by_id(999999));
+}
+
+TEST_CASE("iterate over all features in a layer") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.get_layer_by_name("building");
+    REQUIRE(layer);
+
+    std::size_t count = 0;
+
+    SECTION("external iterator") {
+        while (auto feature = layer.next_feature()) {
+            ++count;
+        }
+    }
+
+    SECTION("internal iterator") {
+        const bool done = layer.for_each_feature([&count](const vtzero::feature& /*feature*/) noexcept {
+            ++count;
+            return true;
+        });
+        REQUIRE(done);
+    }
+
+    REQUIRE(count == 937);
+}
+
+TEST_CASE("iterate over some features in a layer") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.get_layer_by_name("building");
+    REQUIRE(layer);
+
+    uint64_t id_sum = 0;
+
+    SECTION("external iterator") {
+        while (auto feature = layer.next_feature()) {
+            if (feature.id() == 10) {
+                break;
+            }
+            id_sum += feature.id();
+        }
+    }
+
+    SECTION("internal iterator") {
+        const bool done = layer.for_each_feature([&id_sum](const vtzero::feature& feature) noexcept {
+            if (feature.id() == 10) {
+                return false;
+            }
+            id_sum += feature.id();
+            return true;
+        });
+        REQUIRE_FALSE(done);
+    }
+
+    const uint64_t expected = (10 - 1) * 10 / 2;
+    REQUIRE(id_sum == expected);
+
+    layer.reset_feature();
+    auto feature = layer.next_feature();
+    REQUIRE(feature);
+    REQUIRE(feature.id() == 1);
+}
+
diff --git a/third_party/vtzero/test/t/test_output.cpp b/third_party/vtzero/test/t/test_output.cpp
new file mode 100644
index 00000000000..52faff4240f
--- /dev/null
+++ b/third_party/vtzero/test/t/test_output.cpp
@@ -0,0 +1,42 @@
+
+#include <test.hpp>
+
+#include <sstream>
+#include <string>
+
+template <typename T>
+std::string get_output(T v) {
+    std::stringstream ss;
+    ss << v;
+    return ss.str();
+}
+
+TEST_CASE("output GeomType") {
+    REQUIRE(get_output(vtzero::GeomType::UNKNOWN)    == "unknown");
+    REQUIRE(get_output(vtzero::GeomType::POINT)      == "point");
+    REQUIRE(get_output(vtzero::GeomType::LINESTRING) == "linestring");
+    REQUIRE(get_output(vtzero::GeomType::POLYGON)    == "polygon");
+}
+
+TEST_CASE("output property_value_type") {
+    REQUIRE(get_output(vtzero::property_value_type::sint_value) == "sint");
+}
+
+TEST_CASE("output index_value") {
+    REQUIRE(get_output(vtzero::index_value{}) == "invalid");
+    REQUIRE(get_output(vtzero::index_value{5}) == "5");
+}
+
+TEST_CASE("output index_value_pair") {
+    const auto in = vtzero::index_value{};
+    const auto v2 = vtzero::index_value{2};
+    const auto v5 = vtzero::index_value{5};
+    REQUIRE(get_output(vtzero::index_value_pair{in, v2}) == "invalid");
+    REQUIRE(get_output(vtzero::index_value_pair{v2, v5}) == "[2,5]");
+}
+
+TEST_CASE("output point") {
+    REQUIRE(get_output(vtzero::point{}) == "(0,0)");
+    REQUIRE(get_output(vtzero::point{4, 7}) == "(4,7)");
+}
+
diff --git a/third_party/vtzero/test/t/test_point.cpp b/third_party/vtzero/test/t/test_point.cpp
new file mode 100644
index 00000000000..1c3477614e2
--- /dev/null
+++ b/third_party/vtzero/test/t/test_point.cpp
@@ -0,0 +1,25 @@
+
+#include <test.hpp>
+
+#include <vtzero/geometry.hpp>
+
+TEST_CASE("default constructed point") {
+    vtzero::point p{};
+
+    REQUIRE(p.x == 0);
+    REQUIRE(p.y == 0);
+}
+
+TEST_CASE("point") {
+    vtzero::point p1{4, 5};
+    vtzero::point p2{5, 4};
+    vtzero::point p3{4, 5};
+
+    REQUIRE(p1.x == 4);
+    REQUIRE(p1.y == 5);
+
+    REQUIRE_FALSE(p1 == p2);
+    REQUIRE(p1 != p2);
+    REQUIRE(p1 == p3);
+}
+
diff --git a/third_party/vtzero/test/t/test_property_map.cpp b/third_party/vtzero/test/t/test_property_map.cpp
new file mode 100644
index 00000000000..025fe561f1a
--- /dev/null
+++ b/third_party/vtzero/test/t/test_property_map.cpp
@@ -0,0 +1,62 @@
+
+#include <test.hpp>
+
+#include <vtzero/builder.hpp>
+
+#ifdef VTZERO_TEST_WITH_VARIANT
+# include <boost/variant.hpp>
+using variant_type = boost::variant<std::string, float, double, int64_t, uint64_t, bool>;
+#endif
+
+#include <map>
+#include <string>
+#include <unordered_map>
+
+TEST_CASE("property map") {
+    vtzero::tile_builder tile;
+    vtzero::layer_builder layer_points{tile, "points"};
+    {
+        vtzero::point_feature_builder fbuilder{layer_points};
+        fbuilder.set_id(1);
+        fbuilder.add_points(1);
+        fbuilder.set_point(10, 10);
+        fbuilder.add_property("foo", "bar");
+        fbuilder.add_property("x", "y");
+        fbuilder.add_property("abc", "def");
+        fbuilder.commit();
+    }
+
+    std::string data = tile.serialize();
+
+    vtzero::vector_tile vt{data};
+    REQUIRE(vt.count_layers() == 1);
+    auto layer = vt.next_layer();
+    REQUIRE(layer.valid());
+    REQUIRE(layer.num_features() == 1);
+
+    const auto feature = layer.next_feature();
+    REQUIRE(feature.valid());
+    REQUIRE(feature.num_properties() == 3);
+
+#ifdef VTZERO_TEST_WITH_VARIANT
+    SECTION("std::map") {
+        using prop_map_type = std::map<std::string, variant_type>;
+        auto map = vtzero::create_properties_map<prop_map_type>(feature);
+
+        REQUIRE(map.size() == 3);
+        REQUIRE(boost::get<std::string>(map["foo"]) == "bar");
+        REQUIRE(boost::get<std::string>(map["x"]) == "y");
+        REQUIRE(boost::get<std::string>(map["abc"]) == "def");
+    }
+    SECTION("std::unordered_map") {
+        using prop_map_type = std::unordered_map<std::string, variant_type>;
+        auto map = vtzero::create_properties_map<prop_map_type>(feature);
+
+        REQUIRE(map.size() == 3);
+        REQUIRE(boost::get<std::string>(map["foo"]) == "bar");
+        REQUIRE(boost::get<std::string>(map["x"]) == "y");
+        REQUIRE(boost::get<std::string>(map["abc"]) == "def");
+    }
+#endif
+}
+
diff --git a/third_party/vtzero/test/t/test_property_value.cpp b/third_party/vtzero/test/t/test_property_value.cpp
new file mode 100644
index 00000000000..83d76bcd2a6
--- /dev/null
+++ b/third_party/vtzero/test/t/test_property_value.cpp
@@ -0,0 +1,407 @@
+
+#include <test.hpp>
+
+#include <vtzero/encoded_property_value.hpp>
+#include <vtzero/property.hpp>
+#include <vtzero/property_value.hpp>
+#include <vtzero/types.hpp>
+
+#ifdef VTZERO_TEST_WITH_VARIANT
+# include <boost/variant.hpp>
+using variant_type = boost::variant<std::string, float, double, int64_t, uint64_t, bool>;
+
+struct variant_mapping : vtzero::property_value_mapping {
+    using float_type = int64_t;
+    using double_type = int64_t;
+};
+
+#endif
+
+#include <string>
+
+struct visitor_test_void {
+
+    int x = 0;
+
+    template <typename T>
+    void operator()(T /*value*/) {
+        x = 1;
+    }
+
+    void operator()(vtzero::data_view /*value*/) {
+        x = 2;
+    }
+
+};
+
+struct visitor_test_int {
+
+    template <typename T>
+    int operator()(T /*value*/) {
+        return 1;
+    }
+
+    int operator()(vtzero::data_view /*value*/) {
+        return 2;
+    }
+
+};
+
+struct visitor_test_to_string {
+
+    template <typename T>
+    std::string operator()(T value) {
+        return std::to_string(value);
+    }
+
+    std::string operator()(vtzero::data_view value) {
+        return std::string{value.data(), value.size()};
+    }
+
+};
+
+struct string_conv {
+
+    std::string s;
+
+    template <typename T>
+    explicit string_conv(T value) :
+        s(std::to_string(value)) {
+    }
+
+    explicit operator std::string() {
+        return s;
+    }
+
+};
+
+struct string_mapping : vtzero::property_value_mapping {
+    using string_type = std::string;
+    using float_type  = string_conv;
+    using double_type = string_conv;
+    using int_type    = string_conv;
+    using uint_type   = string_conv;
+    using bool_type   = string_conv;
+};
+
+TEST_CASE("default constructed property_value") {
+    vtzero::property_value pv;
+    REQUIRE_FALSE(pv.valid());
+    REQUIRE(pv.data().data() == nullptr);
+
+    REQUIRE(pv == vtzero::property_value{});
+    REQUIRE_FALSE(pv != vtzero::property_value{});
+}
+
+TEST_CASE("empty property_value") {
+    char x[1] = {0};
+    vtzero::data_view dv{x, 0};
+    vtzero::property_value pv{dv};
+    REQUIRE(pv.valid());
+    REQUIRE_THROWS_AS(pv.type(), const vtzero::format_exception&);
+}
+
+TEST_CASE("string value") {
+    vtzero::encoded_property_value epv{"foo"};
+    vtzero::property_value pv{epv.data()};
+    REQUIRE(pv.string_value() == "foo");
+
+    visitor_test_void vt;
+    vtzero::apply_visitor(vt, pv);
+    REQUIRE(vt.x == 2);
+
+    const auto result = vtzero::apply_visitor(visitor_test_int{}, pv);
+    REQUIRE(result == 2);
+
+    const auto str = vtzero::apply_visitor(visitor_test_to_string{}, pv);
+    REQUIRE(str == "foo");
+
+    const std::string cs = vtzero::convert_property_value<std::string, string_mapping>(pv);
+    REQUIRE(cs == "foo");
+
+#ifdef VTZERO_TEST_WITH_VARIANT
+    const auto vari = vtzero::convert_property_value<variant_type>(pv);
+    REQUIRE(boost::get<std::string>(vari) == "foo");
+    const auto conv = vtzero::convert_property_value<variant_type, variant_mapping>(pv);
+    REQUIRE(boost::get<std::string>(conv) == "foo");
+#endif
+}
+
+TEST_CASE("float value") {
+    vtzero::encoded_property_value epv{1.2f};
+    vtzero::property_value pv{epv.data()};
+    REQUIRE(pv.float_value() == Approx(1.2));
+
+    visitor_test_void vt;
+    vtzero::apply_visitor(vt, pv);
+    REQUIRE(vt.x == 1);
+
+    const auto result = vtzero::apply_visitor(visitor_test_int{}, pv);
+    REQUIRE(result == 1);
+
+    const std::string cs = vtzero::convert_property_value<std::string, string_mapping>(pv);
+    REQUIRE(cs == "1.200000");
+
+#ifdef VTZERO_TEST_WITH_VARIANT
+    const auto vari = vtzero::convert_property_value<variant_type>(pv);
+    REQUIRE(boost::get<float>(vari) == Approx(1.2));
+    const auto conv = vtzero::convert_property_value<variant_type, variant_mapping>(pv);
+    REQUIRE(boost::get<int64_t>(conv) == 1);
+#endif
+}
+
+TEST_CASE("double value") {
+    vtzero::encoded_property_value epv{3.4};
+    vtzero::property_value pv{epv.data()};
+    REQUIRE(pv.double_value() == Approx(3.4));
+
+    const auto result = vtzero::apply_visitor(visitor_test_int{}, pv);
+    REQUIRE(result == 1);
+
+    const std::string cs = vtzero::convert_property_value<std::string, string_mapping>(pv);
+    REQUIRE(cs == "3.400000");
+}
+
+TEST_CASE("int value") {
+    vtzero::encoded_property_value epv{vtzero::int_value_type{42}};
+    vtzero::property_value pv{epv.data()};
+    REQUIRE(pv.int_value() == 42);
+
+    const auto str = vtzero::apply_visitor(visitor_test_to_string{}, pv);
+    REQUIRE(str == "42");
+
+    const std::string cs = vtzero::convert_property_value<std::string, string_mapping>(pv);
+    REQUIRE(cs == "42");
+}
+
+TEST_CASE("uint value") {
+    vtzero::encoded_property_value epv{vtzero::uint_value_type{99}};
+    vtzero::property_value pv{epv.data()};
+    REQUIRE(pv.uint_value() == 99);
+
+    const auto str = vtzero::apply_visitor(visitor_test_to_string{}, pv);
+    REQUIRE(str == "99");
+
+    const std::string cs = vtzero::convert_property_value<std::string, string_mapping>(pv);
+    REQUIRE(cs == "99");
+}
+
+TEST_CASE("sint value") {
+    vtzero::encoded_property_value epv{vtzero::sint_value_type{42}};
+    vtzero::property_value pv{epv.data()};
+    REQUIRE(pv.sint_value() == 42);
+
+    const auto str = vtzero::apply_visitor(visitor_test_to_string{}, pv);
+    REQUIRE(str == "42");
+
+    const std::string cs = vtzero::convert_property_value<std::string, string_mapping>(pv);
+    REQUIRE(cs == "42");
+}
+
+TEST_CASE("bool value") {
+    vtzero::encoded_property_value epv{true};
+    vtzero::property_value pv{epv.data()};
+    REQUIRE(pv.bool_value());
+
+    const auto str = vtzero::apply_visitor(visitor_test_to_string{}, pv);
+    REQUIRE(str == "1");
+
+    const std::string cs = vtzero::convert_property_value<std::string, string_mapping>(pv);
+    REQUIRE(cs == "1");
+}
+
+TEST_CASE("property and property_value equality comparisons") {
+    vtzero::encoded_property_value t{true};
+    vtzero::encoded_property_value f{false};
+    vtzero::encoded_property_value v1{vtzero::int_value_type{1}};
+    vtzero::encoded_property_value vs{"foo"};
+
+    REQUIRE(t == t);
+    REQUIRE_FALSE(t != t);
+    REQUIRE_FALSE(t == f);
+    REQUIRE_FALSE(t == v1);
+    REQUIRE_FALSE(t == vs);
+
+    using pv = vtzero::property_value;
+    REQUIRE(pv{t.data()} == pv{t.data()});
+    REQUIRE_FALSE(pv{t.data()} != pv{t.data()});
+    REQUIRE_FALSE(pv{t.data()} == pv{f.data()});
+    REQUIRE_FALSE(pv{t.data()} == pv{v1.data()});
+    REQUIRE_FALSE(pv{t.data()} == pv{vs.data()});
+}
+
+TEST_CASE("property and property_value ordering") {
+    using pv = vtzero::property_value;
+
+    vtzero::encoded_property_value t{true};
+    vtzero::encoded_property_value f{false};
+
+    REQUIRE_FALSE(t <  f);
+    REQUIRE_FALSE(t <= f);
+    REQUIRE(t >  f);
+    REQUIRE(t >= f);
+
+    REQUIRE_FALSE(pv{t.data()} <  pv{f.data()});
+    REQUIRE_FALSE(pv{t.data()} <= pv{f.data()});
+    REQUIRE(pv{t.data()} >  pv{f.data()});
+    REQUIRE(pv{t.data()} >= pv{f.data()});
+
+    vtzero::encoded_property_value v1{vtzero::int_value_type{22}};
+    vtzero::encoded_property_value v2{vtzero::int_value_type{17}};
+
+    REQUIRE_FALSE(v1 <  v2);
+    REQUIRE_FALSE(v1 <= v2);
+    REQUIRE(v1 >  v2);
+    REQUIRE(v1 >= v2);
+
+    REQUIRE_FALSE(pv{v1.data()} <  pv{v2.data()});
+    REQUIRE_FALSE(pv{v1.data()} <= pv{v2.data()});
+    REQUIRE(pv{v1.data()} >  pv{v2.data()});
+    REQUIRE(pv{v1.data()} >= pv{v2.data()});
+
+    vtzero::encoded_property_value vsf{"foo"};
+    vtzero::encoded_property_value vsb{"bar"};
+    vtzero::encoded_property_value vsx{"foobar"};
+
+    REQUIRE_FALSE(vsf <  vsb);
+    REQUIRE_FALSE(vsf <= vsb);
+    REQUIRE(vsf >  vsb);
+    REQUIRE(vsf >= vsb);
+
+    REQUIRE_FALSE(pv{vsf.data()} <  pv{vsb.data()});
+    REQUIRE_FALSE(pv{vsf.data()} <= pv{vsb.data()});
+    REQUIRE(pv{vsf.data()} >  pv{vsb.data()});
+    REQUIRE(pv{vsf.data()} >= pv{vsb.data()});
+
+    REQUIRE(vsf <  vsx);
+    REQUIRE(vsf <= vsx);
+    REQUIRE_FALSE(vsf >  vsx);
+    REQUIRE_FALSE(vsf >= vsx);
+
+    REQUIRE(pv{vsf.data()} <  pv{vsx.data()});
+    REQUIRE(pv{vsf.data()} <= pv{vsx.data()});
+    REQUIRE_FALSE(pv{vsf.data()} >  pv{vsx.data()});
+    REQUIRE_FALSE(pv{vsf.data()} >= pv{vsx.data()});
+}
+
+TEST_CASE("default constructed property") {
+    vtzero::property p;
+    REQUIRE_FALSE(p.valid());
+    REQUIRE_FALSE(p);
+    REQUIRE(p.key().data() == nullptr);
+    REQUIRE(p.value().data().data() == nullptr);
+}
+
+TEST_CASE("valid property") {
+    vtzero::data_view k{"key"};
+    vtzero::encoded_property_value epv{"value"};
+    vtzero::property_value pv{epv.data()};
+
+    vtzero::property p{k, pv};
+    REQUIRE(p.key() == "key");
+    REQUIRE(p.value().string_value() == "value");
+}
+
+TEST_CASE("create encoded property values from different string types") {
+    const std::string v{"value"};
+
+    vtzero::encoded_property_value epv1{vtzero::string_value_type{"value"}};
+    vtzero::encoded_property_value epv2{"value"};
+    vtzero::encoded_property_value epv3{v};
+    vtzero::encoded_property_value epv4{vtzero::data_view{v}};
+    vtzero::encoded_property_value epv5{"valuexxxxxxxxx", 5};
+
+    REQUIRE(epv1 == epv2);
+    REQUIRE(epv1 == epv3);
+    REQUIRE(epv1 == epv4);
+    REQUIRE(epv1 == epv5);
+}
+
+TEST_CASE("create encoded property values from different floating point types") {
+    vtzero::encoded_property_value f1{vtzero::float_value_type{3.2f}};
+    vtzero::encoded_property_value f2{3.2f};
+    vtzero::encoded_property_value d1{vtzero::double_value_type{3.2}};
+    vtzero::encoded_property_value d2{3.2};
+
+    REQUIRE(f1 == f2);
+    REQUIRE(d1 == d2);
+
+    vtzero::property_value pvf{f1.data()};
+    vtzero::property_value pvd{d1.data()};
+
+    REQUIRE(pvf.float_value() == Approx(pvd.double_value()));
+}
+
+TEST_CASE("create encoded property values from different integer types") {
+    vtzero::encoded_property_value i1{vtzero::int_value_type{7}};
+    vtzero::encoded_property_value i2{int64_t(7)};
+    vtzero::encoded_property_value i3{int32_t(7)};
+    vtzero::encoded_property_value i4{int16_t(7)};
+    vtzero::encoded_property_value u1{vtzero::uint_value_type{7}};
+    vtzero::encoded_property_value u2{uint64_t(7)};
+    vtzero::encoded_property_value u3{uint32_t(7)};
+    vtzero::encoded_property_value u4{uint16_t(7)};
+    vtzero::encoded_property_value s1{vtzero::sint_value_type{7}};
+
+    REQUIRE(i1 == i2);
+    REQUIRE(i1 == i3);
+    REQUIRE(i1 == i4);
+    REQUIRE(u1 == u2);
+    REQUIRE(u1 == u3);
+    REQUIRE(u1 == u4);
+
+    REQUIRE_FALSE(i1 == u1);
+    REQUIRE_FALSE(i1 == s1);
+    REQUIRE_FALSE(u1 == s1);
+
+    REQUIRE(i1.hash() == i2.hash());
+    REQUIRE(u1.hash() == u2.hash());
+
+    vtzero::property_value pvi{i1.data()};
+    vtzero::property_value pvu{u1.data()};
+    vtzero::property_value pvs{s1.data()};
+
+    REQUIRE(pvi.int_value() == pvu.uint_value());
+    REQUIRE(pvi.int_value() == pvs.sint_value());
+}
+
+TEST_CASE("create encoded property values from different bool types") {
+    vtzero::encoded_property_value b1{vtzero::bool_value_type{true}};
+    vtzero::encoded_property_value b2{true};
+
+    REQUIRE(b1 == b2);
+    REQUIRE(b1.hash() == b2.hash());
+}
+
+TEST_CASE("property equality comparison operator") {
+    std::string k = "key";
+
+    vtzero::encoded_property_value epv1{"value"};
+    vtzero::encoded_property_value epv2{"another value"};
+    vtzero::property_value pv1{epv1.data()};
+    vtzero::property_value pv2{epv2.data()};
+
+    vtzero::property p1{k, pv1};
+    vtzero::property p2{k, pv1};
+    vtzero::property p3{k, pv2};
+    REQUIRE(p1 == p2);
+    REQUIRE_FALSE(p1 == p3);
+}
+
+TEST_CASE("property inequality comparison operator") {
+    std::string k1 = "key";
+    std::string k2 = "another_key";
+
+    vtzero::encoded_property_value epv1{"value"};
+    vtzero::encoded_property_value epv2{"another value"};
+    vtzero::property_value pv1{epv1.data()};
+    vtzero::property_value pv2{epv2.data()};
+
+    vtzero::property p1{k1, pv1};
+    vtzero::property p2{k1, pv1};
+    vtzero::property p3{k1, pv2};
+    vtzero::property p4{k2, pv2};
+    REQUIRE_FALSE(p1 != p2);
+    REQUIRE(p1 != p3);
+    REQUIRE(p3 != p4);
+}
diff --git a/third_party/vtzero/test/t/test_types.cpp b/third_party/vtzero/test/t/test_types.cpp
new file mode 100644
index 00000000000..efbce93ae2d
--- /dev/null
+++ b/third_party/vtzero/test/t/test_types.cpp
@@ -0,0 +1,116 @@
+
+#include <test.hpp>
+
+#include <vtzero/types.hpp>
+
+#include <string>
+
+TEST_CASE("default constructed string_value_type") {
+    vtzero::string_value_type v;
+    REQUIRE(v.value.data() == nullptr);
+}
+
+TEST_CASE("string_value_type with value") {
+    vtzero::string_value_type v{"foo"};
+    REQUIRE(v.value.data()[0] == 'f');
+    REQUIRE(v.value.size() == 3);
+}
+
+TEST_CASE("default constructed float_value_type") {
+    vtzero::float_value_type v;
+    REQUIRE(v.value == Approx(0.0));
+}
+
+TEST_CASE("float_value_type with value") {
+    float x = 2.7f;
+    vtzero::float_value_type v{x};
+    REQUIRE(v.value == Approx(x));
+}
+
+TEST_CASE("default constructed double_value_type") {
+    vtzero::double_value_type v;
+    REQUIRE(v.value == Approx(0.0));
+}
+
+TEST_CASE("double_value_type with value") {
+    double x = 2.7;
+    vtzero::double_value_type v{x};
+    REQUIRE(v.value == Approx(x));
+}
+
+TEST_CASE("default constructed int_value_type") {
+    vtzero::int_value_type v;
+    REQUIRE(v.value == 0);
+}
+
+TEST_CASE("int_value_type with value") {
+    vtzero::int_value_type v{123};
+    REQUIRE(v.value == 123);
+}
+
+TEST_CASE("default constructed uint_value_type") {
+    vtzero::uint_value_type v;
+    REQUIRE(v.value == 0);
+}
+
+TEST_CASE("uint_value_type with value") {
+    vtzero::uint_value_type v{123};
+    REQUIRE(v.value == 123);
+}
+
+TEST_CASE("default constructed sint_value_type") {
+    vtzero::sint_value_type v;
+    REQUIRE(v.value == 0);
+}
+
+TEST_CASE("sint_value_type with value") {
+    vtzero::sint_value_type v{-14};
+    REQUIRE(v.value == -14);
+}
+
+TEST_CASE("default constructed bool_value_type") {
+    vtzero::bool_value_type v;
+    REQUIRE_FALSE(v.value);
+}
+
+TEST_CASE("bool_value_type with value") {
+    bool x = true;
+    vtzero::bool_value_type v{x};
+    REQUIRE(v.value);
+}
+
+TEST_CASE("property_value_type names") {
+    REQUIRE(std::string{vtzero::property_value_type_name(vtzero::property_value_type::string_value)} == "string");
+    REQUIRE(std::string{vtzero::property_value_type_name(vtzero::property_value_type::float_value)} == "float");
+    REQUIRE(std::string{vtzero::property_value_type_name(vtzero::property_value_type::double_value)} == "double");
+    REQUIRE(std::string{vtzero::property_value_type_name(vtzero::property_value_type::int_value)} == "int");
+    REQUIRE(std::string{vtzero::property_value_type_name(vtzero::property_value_type::uint_value)} == "uint");
+    REQUIRE(std::string{vtzero::property_value_type_name(vtzero::property_value_type::sint_value)} == "sint");
+    REQUIRE(std::string{vtzero::property_value_type_name(vtzero::property_value_type::bool_value)} == "bool");
+}
+
+TEST_CASE("default constructed index value") {
+    vtzero::index_value v;
+    REQUIRE_FALSE(v.valid());
+    REQUIRE_ASSERT(v.value());
+}
+
+TEST_CASE("valid index value") {
+    vtzero::index_value v{32};
+    REQUIRE(v.valid());
+    REQUIRE(v.value() == 32);
+}
+
+TEST_CASE("default constructed geometry") {
+    vtzero::geometry geom;
+    REQUIRE(geom.type() == vtzero::GeomType::UNKNOWN);
+    REQUIRE(geom.data().empty());
+}
+
+TEST_CASE("GeomType names") {
+    REQUIRE(std::string{vtzero::geom_type_name(vtzero::GeomType::UNKNOWN)} == "unknown");
+    REQUIRE(std::string{vtzero::geom_type_name(vtzero::GeomType::POINT)} == "point");
+    REQUIRE(std::string{vtzero::geom_type_name(vtzero::GeomType::LINESTRING)} == "linestring");
+    REQUIRE(std::string{vtzero::geom_type_name(vtzero::GeomType::POLYGON)} == "polygon");
+}
+
diff --git a/third_party/vtzero/test/t/test_vector_tile.cpp b/third_party/vtzero/test/t/test_vector_tile.cpp
new file mode 100644
index 00000000000..ff18332aa09
--- /dev/null
+++ b/third_party/vtzero/test/t/test_vector_tile.cpp
@@ -0,0 +1,139 @@
+
+#include <test.hpp>
+
+#include <vtzero/vector_tile.hpp>
+
+#include <string>
+#include <vector>
+
+TEST_CASE("open a vector tile with string") {
+    const auto data = load_test_tile();
+    REQUIRE(vtzero::is_vector_tile(data));
+    vtzero::vector_tile tile{data};
+
+    REQUIRE_FALSE(tile.empty());
+    REQUIRE(tile.count_layers() == 12);
+}
+
+TEST_CASE("open a vector tile with data_view") {
+    const auto data = load_test_tile();
+    const vtzero::data_view dv{data};
+    vtzero::vector_tile tile{dv};
+
+    REQUIRE_FALSE(tile.empty());
+    REQUIRE(tile.count_layers() == 12);
+}
+
+TEST_CASE("open a vector tile with pointer and size") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data.data(), data.size()};
+
+    REQUIRE_FALSE(tile.empty());
+    REQUIRE(tile.count_layers() == 12);
+}
+
+TEST_CASE("get layer by index") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.get_layer(0);
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "landuse");
+
+    layer = tile.get_layer(1);
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "waterway");
+
+    layer = tile.get_layer(11);
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "waterway_label");
+
+    layer = tile.get_layer(12);
+    REQUIRE_FALSE(layer);
+}
+
+TEST_CASE("get layer by name") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    auto layer = tile.get_layer_by_name("landuse");
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "landuse");
+
+    layer = tile.get_layer_by_name(std::string{"road"});
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "road");
+
+    const vtzero::data_view name{"poi_label"};
+    layer = tile.get_layer_by_name(name);
+    REQUIRE(layer);
+    REQUIRE(layer.name() == "poi_label");
+
+    layer = tile.get_layer_by_name("unknown");
+    REQUIRE_FALSE(layer);
+}
+
+TEST_CASE("iterate over layers") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    std::vector<std::string> names;
+
+    SECTION("external iterator") {
+        while (auto layer = tile.next_layer()) {
+            names.emplace_back(layer.name());
+        }
+    }
+
+    SECTION("internal iterator") {
+        const bool done = tile.for_each_layer([&names](const vtzero::layer& layer) {
+            names.emplace_back(layer.name());
+            return true;
+        });
+        REQUIRE(done);
+    }
+
+    REQUIRE(names.size() == 12);
+
+    static std::vector<std::string> expected = {
+        "landuse", "waterway", "water", "barrier_line", "building", "road",
+        "bridge", "place_label", "water_label", "poi_label", "road_label",
+        "waterway_label"
+    };
+
+    REQUIRE(names == expected);
+
+    tile.reset_layer();
+    int num = 0;
+    while (auto layer = tile.next_layer()) {
+        ++num;
+    }
+    REQUIRE(num == 12);
+}
+
+TEST_CASE("iterate over some of the layers") {
+    const auto data = load_test_tile();
+    vtzero::vector_tile tile{data};
+
+    int num_layers = 0;
+
+    SECTION("external iterator") {
+        while (auto layer = tile.next_layer()) {
+            ++num_layers;
+            if (layer.name() == "water") {
+                break;
+            }
+        }
+    }
+
+    SECTION("internal iterator") {
+        const bool done = tile.for_each_layer([&num_layers](const vtzero::layer& layer) noexcept {
+            ++num_layers;
+            return layer.name() != "water";
+        });
+        REQUIRE_FALSE(done);
+    }
+
+    REQUIRE(num_layers == 3);
+}
+
diff --git a/third_party/vtzero/test/test_main.cpp b/third_party/vtzero/test/test_main.cpp
new file mode 100644
index 00000000000..0978b65822b
--- /dev/null
+++ b/third_party/vtzero/test/test_main.cpp
@@ -0,0 +1,25 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include <test.hpp>
+
+#include <fstream>
+#include <stdexcept>
+#include <string>
+
+bool got_an_assert = false;
+
+std::string load_test_tile() {
+    std::string path{"data/mapbox-streets-v6-14-8714-8017.mvt"};
+    std::ifstream stream{path, std::ios_base::in|std::ios_base::binary};
+    if (!stream.is_open()) {
+        throw std::runtime_error{"could not open: '" + path + "'"};
+    }
+
+    const std::string message{std::istreambuf_iterator<char>(stream.rdbuf()),
+                              std::istreambuf_iterator<char>()};
+
+    stream.close();
+    return message;
+}
+
diff --git a/unit_tests/engine/offline_facade.cpp b/unit_tests/engine/offline_facade.cpp
index d72c68d947b..6314b3a7c2d 100644
--- a/unit_tests/engine/offline_facade.cpp
+++ b/unit_tests/engine/offline_facade.cpp
@@ -325,6 +325,12 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
         return {};
     }
 
+    EdgeWeight GetNodeWeight(const NodeID /*node*/) const { return 0; }
+
+    bool IsForwardEdge(const NodeID /*edge*/) const { return true; }
+
+    bool IsBackwardEdge(const NodeID /*edge*/) const { return true; }
+
     bool HasLaneData(const EdgeID /*id*/) const override { return false; }
     NameID GetNameIndex(const NodeID /*nodeID*/) const override { return EMPTY_NAMEID; }
     StringView GetNameForID(const NameID /*id*/) const override { return StringView{}; }
diff --git a/unit_tests/library/table.cpp b/unit_tests/library/table.cpp
index 45ae643cdb4..f0b7528ae2d 100644
--- a/unit_tests/library/table.cpp
+++ b/unit_tests/library/table.cpp
@@ -27,6 +27,7 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
     params.coordinates.push_back(get_dummy_location());
     params.sources.push_back(0);
     params.destinations.push_back(2);
+    params.annotations = TableParameters::AnnotationsType::All;
 
     json::Object result;
 
@@ -46,6 +47,18 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
         BOOST_CHECK_EQUAL(durations_matrix.size(),
                           params.sources.size() * params.destinations.size());
     }
+
+    // check that returned distances error is expected size and proportions
+    // this test expects a 1x1 matrix
+    const auto &distances_array = result.values.at("distances").get<json::Array>().values;
+    BOOST_CHECK_EQUAL(distances_array.size(), params.sources.size());
+    for (unsigned int i = 0; i < distances_array.size(); i++)
+    {
+        const auto distances_matrix = distances_array[i].get<json::Array>().values;
+        BOOST_CHECK_EQUAL(distances_matrix.size(),
+                          params.sources.size() * params.destinations.size());
+    }
+
     // check destinations array of waypoint objects
     const auto &destinations_array = result.values.at("destinations").get<json::Array>().values;
     BOOST_CHECK_EQUAL(destinations_array.size(), params.destinations.size());
@@ -73,7 +86,6 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
     params.sources.push_back(0);
-
     json::Object result;
 
     const auto rc = osrm.Table(params, result);
@@ -119,6 +131,7 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
+    params.annotations = TableParameters::AnnotationsType::Duration;
 
     json::Object result;
 
diff --git a/unit_tests/library/tile.cpp b/unit_tests/library/tile.cpp
index f46993f82e7..16c073d3425 100644
--- a/unit_tests/library/tile.cpp
+++ b/unit_tests/library/tile.cpp
@@ -14,252 +14,141 @@
 #include "util/typedefs.hpp"
 #include "util/vector_tile.hpp"
 
-#include <protozero/pbf_reader.hpp>
+#include <boost/variant.hpp>
+#include <vtzero/vector_tile.hpp>
+
+#include <map>
 
 #define CHECK_EQUAL_RANGE(R1, R2)                                                                  \
     BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end());
 
 BOOST_AUTO_TEST_SUITE(tile)
 
-void validate_value(protozero::pbf_reader value)
+using variant_type = boost::variant<std::string, float, double, int64_t, uint64_t, bool>;
+
+std::string to_string(const protozero::data_view &view)
 {
-    using namespace osrm;
-    while (value.next())
+    return std::string{view.data(), view.size()};
+}
+
+void validate_feature_layer(vtzero::layer layer)
+{
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "speeds");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 7);
+    BOOST_CHECK(layer.num_features() > 2500);
+
+    while (auto feature = layer.next_feature())
     {
-        switch (value.tag())
-        {
-        case util::vector_tile::VARIANT_TYPE_BOOL:
-            value.get_bool();
-            break;
-        case util::vector_tile::VARIANT_TYPE_DOUBLE:
-            value.get_double();
-            break;
-        case util::vector_tile::VARIANT_TYPE_FLOAT:
-            value.get_float();
-            break;
-        case util::vector_tile::VARIANT_TYPE_STRING:
-            value.get_string();
-            break;
-        case util::vector_tile::VARIANT_TYPE_UINT64:
-            value.get_uint64();
-            break;
-        case util::vector_tile::VARIANT_TYPE_SINT64:
-            value.get_sint64();
-            break;
-        }
+        BOOST_CHECK(feature.has_id());
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::LINESTRING);
+        BOOST_CHECK(!feature.empty());
+
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
+
+        BOOST_CHECK(props.find("speed") != props.end());
+        BOOST_CHECK(props["speed"].type() == typeid(uint64_t));
+
+        BOOST_CHECK(props.find("rate") != props.end());
+        BOOST_CHECK(props["rate"].type() == typeid(double));
+
+        BOOST_CHECK(props.find("weight") != props.end());
+        BOOST_CHECK(props["weight"].type() == typeid(double));
+
+        BOOST_CHECK(props.find("duration") != props.end());
+        BOOST_CHECK(props["duration"].type() == typeid(double));
+
+        BOOST_CHECK(props.find("is_small") != props.end());
+        BOOST_CHECK(props["is_small"].type() == typeid(bool));
+
+        BOOST_CHECK(props.find("datasource") != props.end());
+        BOOST_CHECK(props["datasource"].type() == typeid(std::string));
+
+        BOOST_CHECK(props.find("name") != props.end());
+        BOOST_CHECK(props["name"].type() == typeid(std::string));
     }
+
+    auto number_of_uint_values =
+        std::count_if(layer.value_table().begin(), layer.value_table().end(), [](auto v) {
+            return v.type() == vtzero::property_value_type::uint_value;
+        });
+    BOOST_CHECK_EQUAL(number_of_uint_values, 77);
 }
 
-void validate_feature_layer(protozero::pbf_reader &layer_message)
+void validate_turn_layer(vtzero::layer layer)
 {
-    using namespace osrm;
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "turns");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 6);
+    BOOST_CHECK(layer.num_features() > 700);
 
-    const auto check_feature = [](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_LINE);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto property_iter_pair = feature_message.get_packed_uint32();
-        auto value_begin = property_iter_pair.begin();
-        auto value_end = property_iter_pair.end();
-        BOOST_CHECK_EQUAL(std::distance(value_begin, value_end), 14);
-        auto iter = value_begin;
-        BOOST_CHECK_EQUAL(*iter++, 0); // speed key
-        BOOST_CHECK_LT(*iter++, 128);  // speed value
-        BOOST_CHECK_EQUAL(*iter++, 1); // component key
-        // component value
-        BOOST_CHECK_GE(*iter, 128);
-        BOOST_CHECK_LE(*iter, 129);
-        iter++;
-        BOOST_CHECK_EQUAL(*iter++, 2); // data source key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 3); // weight key
-        BOOST_CHECK_GT(*iter++, 130);  // weight value
-        BOOST_CHECK_EQUAL(*iter++, 4); // duration key
-        BOOST_CHECK_GT(*iter++, 130);  // duration value
-        // name
-        BOOST_CHECK_EQUAL(*iter++, 5);
-        BOOST_CHECK_GT(*iter++, 130);
-        // rate
-        BOOST_CHECK_EQUAL(*iter++, 6);
-        BOOST_CHECK_GT(*iter++, 130);
-        BOOST_CHECK(iter == value_end);
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    auto number_of_speed_keys = 0u;
-    auto number_of_speed_values = 0u;
-
-    while (layer_message.next())
+    while (auto feature = layer.next_feature())
     {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "speeds");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_feature(layer_message.get_message());
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_speed_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            validate_value(layer_message.get_message());
-            number_of_speed_values++;
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
+        BOOST_CHECK(feature.has_id());
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::POINT);
+        BOOST_CHECK(!feature.empty());
+
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
+
+        BOOST_CHECK(props.find("bearing_in") != props.end());
+        BOOST_CHECK(props["bearing_in"].type() == typeid(std::int64_t));
+
+        BOOST_CHECK(props.find("turn_angle") != props.end());
+        BOOST_CHECK(props["turn_angle"].type() == typeid(std::int64_t));
+
+        BOOST_CHECK(props.find("weight") != props.end());
+        BOOST_CHECK(props["weight"].type() == typeid(float));
+
+        BOOST_CHECK(props.find("cost") != props.end());
+        BOOST_CHECK(props["cost"].type() == typeid(float));
+
+        BOOST_CHECK(props.find("type") != props.end());
+        BOOST_CHECK(props["type"].type() == typeid(std::string));
+
+        BOOST_CHECK(props.find("modifier") != props.end());
+        BOOST_CHECK(props["modifier"].type() == typeid(std::string));
     }
 
-    BOOST_CHECK_EQUAL(number_of_speed_keys, 7);
-    BOOST_CHECK_GT(number_of_speed_values, 128); // speed value resolution
+    auto number_of_float_values =
+        std::count_if(layer.value_table().begin(), layer.value_table().end(), [](auto v) {
+            return v.type() == vtzero::property_value_type::float_value;
+        });
+
+    BOOST_CHECK_EQUAL(number_of_float_values, 74);
 }
 
-void validate_turn_layer(protozero::pbf_reader &layer_message)
+void validate_node_layer(vtzero::layer layer)
 {
-    using namespace osrm;
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "osmnodes");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 0);
+    BOOST_CHECK_EQUAL(layer.num_features(), 1791);
 
-    const auto check_turn_feature = [](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto feature_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_EQUAL(std::distance(feature_iter_pair.begin(), feature_iter_pair.end()), 12);
-        auto iter = feature_iter_pair.begin();
-        BOOST_CHECK_EQUAL(*iter++, 0); // bearing_in key
-        *iter++;
-        BOOST_CHECK_EQUAL(*iter++, 1); // turn_angle key
-        *iter++;
-        BOOST_CHECK_EQUAL(*iter++, 2); // turn cost (duration) key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 3); // turn weight key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 4); // turn type key
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 5); // turn modifier
-        *iter++;                       // skip value check, can be valud uint32
-        BOOST_CHECK(iter == feature_iter_pair.end());
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    auto number_of_turn_keys = 0u;
-    auto number_of_turns_found = 0u;
-
-    while (layer_message.next())
+    while (auto feature = layer.next_feature())
     {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "turns");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_turn_feature(layer_message.get_message());
-            number_of_turns_found++;
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_turn_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            validate_value(layer_message.get_message());
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
+        BOOST_CHECK(feature.has_id());
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::POINT);
+        BOOST_CHECK(feature.empty());
     }
-
-    BOOST_CHECK_EQUAL(number_of_turn_keys, 6);
-    BOOST_CHECK(number_of_turns_found > 700);
 }
 
-void validate_node_layer(protozero::pbf_reader &layer_message)
+void validate_internal_nodes_layer(vtzero::layer layer)
 {
-    using namespace osrm;
-    auto number_of_nodes_found = 0u;
-
-    const auto check_osmnode_feature = [](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        // Note - on this layer, there should be no feature attributes, the next thing
-        // we get should be the geometry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_GEOMETRIES_TAG);
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    while (layer_message.next())
+    BOOST_CHECK_EQUAL(layer.version(), 2);
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "internal-nodes");
+    BOOST_CHECK_EQUAL(layer.extent(), osrm::util::vector_tile::EXTENT);
+    BOOST_CHECK_EQUAL(layer.key_table().size(), 0);
+    BOOST_CHECK_EQUAL(layer.num_features(), 24);
+
+    while (auto feature = layer.next_feature())
     {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "osmnodes");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_osmnode_feature(layer_message.get_message());
-            number_of_nodes_found++;
-            break;
-        case util::vector_tile::KEY_TAG:
-            BOOST_CHECK(false); // There should be no properties on node features
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            BOOST_CHECK(false); // There should be no properties on node features
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
+        BOOST_CHECK(!feature.has_id());
+        BOOST_CHECK(feature.geometry_type() == vtzero::GeomType::LINESTRING);
+        BOOST_CHECK(feature.empty());
     }
-    BOOST_CHECK_EQUAL(number_of_nodes_found, 1791);
 }
 
 void validate_tile(const osrm::OSRM &osrm)
@@ -275,22 +164,12 @@ void validate_tile(const osrm::OSRM &osrm)
 
     BOOST_CHECK(result.size() > 114000);
 
-    protozero::pbf_reader tile_message(result);
-
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    protozero::pbf_reader layer_message = tile_message.get_message();
-    validate_feature_layer(layer_message);
+    vtzero::vector_tile tile{result};
 
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    layer_message = tile_message.get_message();
-    validate_turn_layer(layer_message);
-
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    layer_message = tile_message.get_message();
-    validate_node_layer(layer_message);
+    validate_feature_layer(tile.next_layer());
+    validate_turn_layer(tile.next_layer());
+    validate_node_layer(tile.next_layer());
+    validate_internal_nodes_layer(tile.next_layer());
 }
 
 BOOST_AUTO_TEST_CASE(test_tile_ch)
@@ -330,147 +209,50 @@ void test_tile_turns(const osrm::OSRM &osrm)
 
     BOOST_CHECK_GT(result.size(), 128);
 
-    protozero::pbf_reader tile_message(result);
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    // Skip the segments layer
-    tile_message.skip();
-
-    tile_message.next();
-    auto layer_message = tile_message.get_message();
-
-    std::vector<int> found_bearing_in_indexes;
-    std::vector<int> found_turn_angles_indexes;
-    std::vector<int> found_time_penalties_indexes;
-    std::vector<int> found_weight_penalties_indexes;
-    std::vector<int> found_turn_type_indexes;
-    std::vector<int> found_turn_modifier_indexes;
-
-    const auto check_turn_feature = [&](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto feature_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_EQUAL(std::distance(feature_iter_pair.begin(), feature_iter_pair.end()), 12);
-        auto iter = feature_iter_pair.begin();
-        BOOST_CHECK_EQUAL(*iter++, 0); // bearing_in key
-        found_bearing_in_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 1); // turn_angle key
-        found_turn_angles_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 2);                     // "cost" key (actually duration)
-        found_time_penalties_indexes.push_back(*iter++);   // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 3);                     // "weight" key
-        found_weight_penalties_indexes.push_back(*iter++); // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 4);                     // "weight" key
-        found_turn_type_indexes.push_back(*iter++);        // skip value check, can be valud uint32
-        BOOST_CHECK_EQUAL(*iter++, 5);                     // "weight" key
-        found_turn_modifier_indexes.push_back(*iter++);    // skip value check, can be valud uint32
-        BOOST_CHECK(iter == feature_iter_pair.end());
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    std::unordered_map<int, float> float_vals;
-    std::unordered_map<int, std::int64_t> sint64_vals;
-    std::unordered_map<int, std::string> string_vals;
-
-    int kv_index = 0;
-
-    const auto check_value = [&](protozero::pbf_reader value) {
-        while (value.next())
-        {
-            switch (value.tag())
-            {
-            case util::vector_tile::VARIANT_TYPE_FLOAT:
-                float_vals[kv_index] = value.get_float();
-                break;
-            case util::vector_tile::VARIANT_TYPE_SINT64:
-                sint64_vals[kv_index] = value.get_sint64();
-                break;
-            case util::vector_tile::VARIANT_TYPE_STRING:
-                string_vals[kv_index] = value.get_string();
-                break;
-            default:
-                BOOST_CHECK(false);
-            }
-            kv_index++;
-        }
-    };
-
-    auto number_of_turn_keys = 0u;
-    auto number_of_turns_found = 0u;
-
-    while (layer_message.next())
-    {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "turns");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_turn_feature(layer_message.get_message());
-            number_of_turns_found++;
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_turn_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            check_value(layer_message.get_message());
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
-    }
+    vtzero::vector_tile tile{result};
+
+    tile.next_layer();
+    auto layer = tile.next_layer();
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "turns");
 
-    // Verify that we got the expected turn penalties
     std::vector<float> actual_time_turn_penalties;
-    for (const auto &i : found_time_penalties_indexes)
+    std::vector<float> actual_weight_turn_penalties;
+    std::vector<std::string> actual_turn_types;
+    std::vector<std::string> actual_turn_modifiers;
+    std::vector<std::int64_t> actual_turn_angles;
+    std::vector<std::int64_t> actual_turn_bearings;
+
+    while (auto feature = layer.next_feature())
     {
-        BOOST_CHECK(float_vals.count(i) == 1);
-        actual_time_turn_penalties.push_back(float_vals[i]);
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
+
+        BOOST_CHECK(props["cost"].type() == typeid(float));
+        actual_time_turn_penalties.push_back(boost::get<float>(props["cost"]));
+        BOOST_CHECK(props["weight"].type() == typeid(float));
+        actual_weight_turn_penalties.push_back(boost::get<float>(props["weight"]));
+        BOOST_CHECK(props["turn_angle"].type() == typeid(std::int64_t));
+        actual_turn_angles.push_back(boost::get<std::int64_t>(props["turn_angle"]));
+        BOOST_CHECK(props["bearing_in"].type() == typeid(std::int64_t));
+        actual_turn_bearings.push_back(boost::get<std::int64_t>(props["bearing_in"]));
+        BOOST_CHECK(props["type"].type() == typeid(std::string));
+        actual_turn_types.push_back(boost::get<std::string>(props["type"]));
+        BOOST_CHECK(props["modifier"].type() == typeid(std::string));
+        actual_turn_modifiers.push_back(boost::get<std::string>(props["modifier"]));
     }
+
+    // Verify that we got the expected turn penalties
     std::sort(actual_time_turn_penalties.begin(), actual_time_turn_penalties.end());
     const std::vector<float> expected_time_turn_penalties = {
         0, 0, 0, 0, 0, 0, .1f, .1f, .3f, .4f, 1.2f, 1.9f, 5.3f, 5.5f, 5.8f, 7.1f, 7.2f, 7.2f};
     CHECK_EQUAL_RANGE(actual_time_turn_penalties, expected_time_turn_penalties);
 
     // Verify that we got the expected turn penalties
-    std::vector<float> actual_weight_turn_penalties;
-    for (const auto &i : found_weight_penalties_indexes)
-    {
-        BOOST_CHECK(float_vals.count(i) == 1);
-        actual_weight_turn_penalties.push_back(float_vals[i]);
-    }
     std::sort(actual_weight_turn_penalties.begin(), actual_weight_turn_penalties.end());
     const std::vector<float> expected_weight_turn_penalties = {
         0, 0, 0, 0, 0, 0, .1f, .1f, .3f, .4f, 1.2f, 1.9f, 5.3f, 5.5f, 5.8f, 7.1f, 7.2f, 7.2f};
     CHECK_EQUAL_RANGE(actual_weight_turn_penalties, expected_weight_turn_penalties);
 
     // Verify that we got the expected turn types
-    std::vector<std::string> actual_turn_types;
-    for (const auto &i : found_turn_type_indexes)
-    {
-        BOOST_CHECK(string_vals.count(i) == 1);
-        actual_turn_types.push_back(string_vals[i]);
-    }
     std::sort(actual_turn_types.begin(), actual_turn_types.end());
     const std::vector<std::string> expected_turn_types = {"(noturn)",
                                                           "(noturn)",
@@ -493,12 +275,6 @@ void test_tile_turns(const osrm::OSRM &osrm)
     CHECK_EQUAL_RANGE(actual_turn_types, expected_turn_types);
 
     // Verify that we got the expected turn modifiers
-    std::vector<std::string> actual_turn_modifiers;
-    for (const auto &i : found_turn_modifier_indexes)
-    {
-        BOOST_CHECK(string_vals.count(i) == 1);
-        actual_turn_modifiers.push_back(string_vals[i]);
-    }
     std::sort(actual_turn_modifiers.begin(), actual_turn_modifiers.end());
     const std::vector<std::string> expected_turn_modifiers = {"left",
                                                               "left",
@@ -521,24 +297,12 @@ void test_tile_turns(const osrm::OSRM &osrm)
     CHECK_EQUAL_RANGE(actual_turn_modifiers, expected_turn_modifiers);
 
     // Verify the expected turn angles
-    std::vector<std::int64_t> actual_turn_angles;
-    for (const auto &i : found_turn_angles_indexes)
-    {
-        BOOST_CHECK(sint64_vals.count(i) == 1);
-        actual_turn_angles.push_back(sint64_vals[i]);
-    }
     std::sort(actual_turn_angles.begin(), actual_turn_angles.end());
     const std::vector<std::int64_t> expected_turn_angles = {
         -122, -120, -117, -65, -57, -30, -28, -3, -2, 2, 3, 28, 30, 57, 65, 117, 120, 122};
     CHECK_EQUAL_RANGE(actual_turn_angles, expected_turn_angles);
 
     // Verify the expected bearings
-    std::vector<std::int64_t> actual_turn_bearings;
-    for (const auto &i : found_bearing_in_indexes)
-    {
-        BOOST_CHECK(sint64_vals.count(i) == 1);
-        actual_turn_bearings.push_back(sint64_vals[i]);
-    }
     std::sort(actual_turn_bearings.begin(), actual_turn_bearings.end());
     const std::vector<std::int64_t> expected_turn_bearings = {
         49, 49, 107, 107, 169, 169, 171, 171, 229, 229, 257, 257, 286, 286, 349, 349, 352, 352};
@@ -586,132 +350,18 @@ void test_tile_speeds(const osrm::OSRM &osrm)
 
     BOOST_CHECK_GT(result.size(), 128);
 
-    protozero::pbf_reader tile_message(result);
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-    protozero::pbf_reader layer_message = tile_message.get_message();
-
-    std::vector<int> found_speed_indexes;
-    std::vector<int> found_component_indexes;
-    std::vector<int> found_datasource_indexes;
-    std::vector<int> found_weight_indexes;
-    std::vector<int> found_duration_indexes;
-    std::vector<int> found_name_indexes;
-    std::vector<int> found_rate_indexes;
-
-    const auto check_feature = [&](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_LINE);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        feature_message.get_uint64(); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG);
-        // properties
-        auto property_iter_pair = feature_message.get_packed_uint32();
-        auto value_begin = property_iter_pair.begin();
-        auto value_end = property_iter_pair.end();
-        BOOST_CHECK_EQUAL(std::distance(value_begin, value_end), 14);
-        auto iter = value_begin;
-        BOOST_CHECK_EQUAL(*iter++, 0); // speed key
-        found_speed_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 1); // component key
-        // component value
-        found_component_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 2); // data source key
-        found_datasource_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 3); // weight key
-        found_weight_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 4); // duration key
-        found_duration_indexes.push_back(*iter++);
-        // name
-        BOOST_CHECK_EQUAL(*iter++, 5);
-        found_name_indexes.push_back(*iter++);
-        BOOST_CHECK_EQUAL(*iter++, 6);
-        found_rate_indexes.push_back(*iter++);
-        BOOST_CHECK(iter == value_end);
-        // geometry
-        feature_message.next();
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    std::unordered_map<int, std::string> string_vals;
-    std::unordered_map<int, bool> bool_vals;
-    std::unordered_map<int, std::uint64_t> uint64_vals;
-    std::unordered_map<int, double> double_vals;
-
-    int kv_index = 0;
-
-    const auto check_value = [&](protozero::pbf_reader value) {
-        while (value.next())
-        {
-            switch (value.tag())
-            {
-            case util::vector_tile::VARIANT_TYPE_BOOL:
-                bool_vals[kv_index] = value.get_bool();
-                break;
-            case util::vector_tile::VARIANT_TYPE_DOUBLE:
-                double_vals[kv_index] = value.get_double();
-                break;
-            case util::vector_tile::VARIANT_TYPE_FLOAT:
-                value.get_float();
-                break;
-            case util::vector_tile::VARIANT_TYPE_STRING:
-                string_vals[kv_index] = value.get_string();
-                break;
-            case util::vector_tile::VARIANT_TYPE_UINT64:
-                uint64_vals[kv_index] = value.get_uint64();
-                break;
-            case util::vector_tile::VARIANT_TYPE_SINT64:
-                value.get_sint64();
-                break;
-            }
-            kv_index++;
-        }
-    };
-
-    auto number_of_speed_keys = 0u;
-    auto number_of_speed_values = 0u;
-
-    while (layer_message.next())
-    {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "speeds");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_feature(layer_message.get_message());
-            break;
-        case util::vector_tile::KEY_TAG:
-            layer_message.get_string();
-            number_of_speed_keys++;
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            check_value(layer_message.get_message());
-            number_of_speed_values++;
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
-    }
+    vtzero::vector_tile tile{result};
+
+    auto layer = tile.next_layer();
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "speeds");
 
     std::vector<std::string> actual_names;
-    for (const auto &i : found_name_indexes)
+    while (auto feature = layer.next_feature())
     {
-        BOOST_CHECK(string_vals.count(i) == 1);
-        actual_names.push_back(string_vals[i]);
+        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);
+
+        BOOST_CHECK(props["name"].type() == typeid(std::string));
+        actual_names.push_back(boost::get<std::string>(props["name"]));
     }
     std::sort(actual_names.begin(), actual_names.end());
     const std::vector<std::string> expected_names = {"Avenue du Carnier",
@@ -780,62 +430,17 @@ void test_tile_nodes(const osrm::OSRM &osrm)
 
     BOOST_CHECK_GT(result.size(), 128);
 
-    protozero::pbf_reader tile_message(result);
-    tile_message.next();
-    BOOST_CHECK_EQUAL(tile_message.tag(), util::vector_tile::LAYER_TAG); // must be a layer
-
-    // Skip the segments and turns layers
-    tile_message.skip();
-    tile_message.next();
-    tile_message.skip();
+    vtzero::vector_tile tile{result};
 
-    // Get the osmnodes layer
-    tile_message.next();
-    protozero::pbf_reader layer_message = tile_message.get_message();
+    tile.next_layer();
+    tile.next_layer();
+    auto layer = tile.next_layer();
+    BOOST_CHECK_EQUAL(to_string(layer.name()), "osmnodes");
 
     std::vector<OSMNodeID::value_type> found_node_ids;
-
-    const auto check_feature = [&](protozero::pbf_reader feature_message) {
-        feature_message.next(); // advance parser to first entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG);
-        BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT);
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG);
-        found_node_ids.push_back(feature_message.get_uint64()); // id
-
-        feature_message.next(); // advance to next entry
-        BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_GEOMETRIES_TAG);
-        auto geometry_iter_pair = feature_message.get_packed_uint32();
-        BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1);
-    };
-
-    while (layer_message.next())
+    while (auto feature = layer.next_feature())
     {
-        switch (layer_message.tag())
-        {
-        case util::vector_tile::VERSION_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2);
-            break;
-        case util::vector_tile::NAME_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_string(), "osmnodes");
-            break;
-        case util::vector_tile::EXTENT_TAG:
-            BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT);
-            break;
-        case util::vector_tile::FEATURE_TAG:
-            check_feature(layer_message.get_message());
-            break;
-        case util::vector_tile::KEY_TAG:
-            BOOST_CHECK(false); // There should be no keys
-            break;
-        case util::vector_tile::VARIANT_TAG:
-            BOOST_CHECK(false); // There should be no values
-            break;
-        default:
-            BOOST_CHECK(false); // invalid tag
-            break;
-        }
+        found_node_ids.push_back(feature.id());
     }
 
     std::sort(found_node_ids.begin(), found_node_ids.end());
diff --git a/unit_tests/mocks/mock_datafacade.hpp b/unit_tests/mocks/mock_datafacade.hpp
index 75a864fd85e..2342d47527c 100644
--- a/unit_tests/mocks/mock_datafacade.hpp
+++ b/unit_tests/mocks/mock_datafacade.hpp
@@ -56,7 +56,9 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     }
     NodeForwardRange GetUncompressedForwardGeometry(const EdgeID /* id */) const override
     {
-        return {};
+        static NodeID data[] = {0, 1, 2, 3};
+        static extractor::SegmentDataView::SegmentNodeVector nodes(data, 4);
+        return boost::make_iterator_range(nodes.cbegin(), nodes.cend());
     }
     NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const override
     {
@@ -73,7 +75,6 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     {
         return WeightReverseRange(GetUncompressedForwardWeights(id));
     }
-
     DurationForwardRange GetUncompressedForwardDurations(const EdgeID /*id*/) const override
     {
         static std::uint64_t data[] = {1, 2, 3};
diff --git a/unit_tests/server/parameters_parser.cpp b/unit_tests/server/parameters_parser.cpp
index 448b624e44e..4d3b8c53b59 100644
--- a/unit_tests/server/parameters_parser.cpp
+++ b/unit_tests/server/parameters_parser.cpp
@@ -86,15 +86,20 @@ BOOST_AUTO_TEST_CASE(invalid_table_urls)
         testInvalidOptions<TableParameters>("1,2;3,4?sources=1&destinations=1&bla=foo"), 32UL);
     BOOST_CHECK_EQUAL(testInvalidOptions<TableParameters>("1,2;3,4?sources=foo"), 16UL);
     BOOST_CHECK_EQUAL(testInvalidOptions<TableParameters>("1,2;3,4?destinations=foo"), 21UL);
+    BOOST_CHECK_EQUAL(
+        testInvalidOptions<TableParameters>("1,2;3,4?sources=all&destinations=all&annotations=bla"),
+        49UL);
 }
 
 BOOST_AUTO_TEST_CASE(valid_route_hint)
 {
-    auto hint = engine::Hint::FromBase64("ZgYAgP___38EAAAAIAAAAD4AAAAdAAAABAAAACAAAAA-"
-                                         "AAAAHQAAABQAAABqaHEAt4KbAjtocQDLgpsCBQAPAJDIe3E=");
-    BOOST_CHECK_EQUAL(
-        hint.phantom.input_location,
-        util::Coordinate(util::FloatLongitude{7.432251}, util::FloatLatitude{43.745995}));
+    engine::PhantomNode reference_node;
+    reference_node.input_location =
+        util::Coordinate(util::FloatLongitude{7.432251}, util::FloatLatitude{43.745995});
+    engine::Hint reference_hint{reference_node, 0x1337};
+    auto encoded_hint = reference_hint.ToBase64();
+    auto hint = engine::Hint::FromBase64(encoded_hint);
+    BOOST_CHECK_EQUAL(hint.phantom.input_location, reference_hint.phantom.input_location);
 }
 
 BOOST_AUTO_TEST_CASE(valid_route_urls)
@@ -166,13 +171,12 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     CHECK_EQUAL_RANGE(reference_3.coordinates, result_3->coordinates);
     CHECK_EQUAL_RANGE(reference_3.hints, result_3->hints);
 
-    std::vector<boost::optional<engine::Hint>> hints_4 = {
-        engine::Hint::FromBase64("ZgYAgP___38EAAAAIAAAAD4AAAAdAAAABAAAACAAAAA-AAAAHQAAABQAAA"
-                                 "BqaHEAt4KbAjtocQDLgpsCBQAPAJDIe3E="),
-        engine::Hint::FromBase64("ngQAgP___38TAAAAGAAAAC8AAAA4AAAAEwAAABgAAAAvAAAAOAAAABQAAA"
-                                 "CaYXEAvnObAtxhcQC7c5sCBAAPAJDIe3E="),
-        engine::Hint::FromBase64("QAUAgM0FAIAYAAAABAAAAAAAAADxAAAAGAAAAAQAAAAAAAAA8QAAABQAAA"
-                                 "CDPnEAUFabAog-cQBQVpsCAAAPAJDIe3E=")};
+    engine::PhantomNode phantom_1;
+    phantom_1.input_location = coords_1[0];
+    engine::PhantomNode phantom_2;
+    phantom_2.input_location = coords_1[1];
+    std::vector<boost::optional<engine::Hint>> hints_4 = {engine::Hint{phantom_1, 0x1337},
+                                                          engine::Hint{phantom_2, 0x1337}};
     RouteParameters reference_4{false,
                                 false,
                                 false,
@@ -184,13 +188,7 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                 std::vector<boost::optional<double>>{},
                                 std::vector<boost::optional<engine::Bearing>>{}};
     auto result_4 = parseParameters<RouteParameters>(
-        "1,2;3,4?steps=false&hints="
-        "ZgYAgP___38EAAAAIAAAAD4AAAAdAAAABAAAACAAAAA-"
-        "AAAAHQAAABQAAABqaHEAt4KbAjtocQDLgpsCBQAPAJDIe3E=;"
-        "ngQAgP___"
-        "38TAAAAGAAAAC8AAAA4AAAAEwAAABgAAAAvAAAAOAAAABQAAACaYXEAvnObAtxhcQC7c5sCBAAPAJDIe3E=;"
-        "QAUAgM0FAIAYAAAABAAAAAAAAADxAAAAGAAAAAQAAAAAAAAA8QAAABQAAACDPnEAUFabAog-"
-        "cQBQVpsCAAAPAJDIe3E=");
+        "1,2;3,4?steps=false&hints=" + hints_4[0]->ToBase64() + ";" + hints_4[1]->ToBase64());
     BOOST_CHECK(result_4);
     BOOST_CHECK_EQUAL(reference_4.steps, result_4->steps);
     BOOST_CHECK_EQUAL(reference_4.alternatives, result_4->alternatives);
@@ -288,13 +286,14 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                               {util::FloatLongitude{3}, util::FloatLatitude{4}},
                                               {util::FloatLongitude{5}, util::FloatLatitude{6}},
                                               {util::FloatLongitude{7}, util::FloatLatitude{8}}};
+
+    engine::PhantomNode phantom_3;
+    phantom_3.input_location = coords_3[0];
+    engine::PhantomNode phantom_4;
+    phantom_4.input_location = coords_3[2];
     std::vector<boost::optional<engine::Hint>> hints_10 = {
-        engine::Hint::FromBase64("ZgYAgP___38EAAAAIAAAAD4AAAAdAAAABAAAACAAAAA-"
-                                 "AAAAHQAAABQAAABqaHEAt4KbAjtocQDLgpsCBQAPAJDIe3E="),
-        boost::none,
-        engine::Hint::FromBase64("QAUAgM0FAIAYAAAABAAAAAAAAADxAAAAGAAAAAQAAAAAAAAA8QAAABQAAACDPnEAU"
-                                 "FabAog-cQBQVpsCAAAPAJDIe3E="),
-        boost::none};
+        engine::Hint{phantom_3, 0x1337}, boost::none, engine::Hint{phantom_4, 0x1337}, boost::none};
+
     RouteParameters reference_10{false,
                                  false,
                                  false,
@@ -305,12 +304,9 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                  hints_10,
                                  std::vector<boost::optional<double>>{},
                                  std::vector<boost::optional<engine::Bearing>>{}};
-    auto result_10 =
-        parseParameters<RouteParameters>("1,2;3,4;5,6;7,8?steps=false&hints="
-                                         "ZgYAgP___38EAAAAIAAAAD4AAAAdAAAABAAAACAAAAA-"
-                                         "AAAAHQAAABQAAABqaHEAt4KbAjtocQDLgpsCBQAPAJDIe3E=;;"
-                                         "QAUAgM0FAIAYAAAABAAAAAAAAADxAAAAGAAAAAQAAAAAAAAA8QAAABQAA"
-                                         "ACDPnEAUFabAog-cQBQVpsCAAAPAJDIe3E=;");
+    auto result_10 = parseParameters<RouteParameters>("1,2;3,4;5,6;7,8?steps=false&hints=" +
+                                                      hints_10[0]->ToBase64() + ";;" +
+                                                      hints_10[2]->ToBase64() + ";");
     BOOST_CHECK(result_10);
     BOOST_CHECK_EQUAL(reference_10.steps, result_10->steps);
     BOOST_CHECK_EQUAL(reference_10.alternatives, result_10->alternatives);
@@ -386,11 +382,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                          "overview=simplified&annotations=duration,weight,nodes");
     BOOST_CHECK(result_16);
     BOOST_CHECK_EQUAL(reference_16.geometries, result_16->geometries);
-    BOOST_CHECK_EQUAL(
-        static_cast<bool>(result_2->annotations_type & (RouteParameters::AnnotationsType::Weight |
-                                                        RouteParameters::AnnotationsType::Duration |
-                                                        RouteParameters::AnnotationsType::Nodes)),
-        true);
+    BOOST_CHECK_EQUAL(static_cast<bool>(result_16->annotations_type &
+                                        (RouteParameters::AnnotationsType::Weight |
+                                         RouteParameters::AnnotationsType::Duration |
+                                         RouteParameters::AnnotationsType::Nodes)),
+                      true);
     BOOST_CHECK_EQUAL(result_16->annotations, true);
 
     // parse all annotations correctly
@@ -530,6 +526,43 @@ BOOST_AUTO_TEST_CASE(valid_table_urls)
     CHECK_EQUAL_RANGE(reference_1.radiuses, result_3->radiuses);
     CHECK_EQUAL_RANGE(reference_1.approaches, result_3->approaches);
     CHECK_EQUAL_RANGE(reference_1.coordinates, result_3->coordinates);
+
+    TableParameters reference_4{};
+    reference_4.coordinates = coords_1;
+    auto result_4 = parseParameters<TableParameters>(
+        "1,2;3,4?sources=all&destinations=all&annotations=duration");
+    BOOST_CHECK(result_4);
+    BOOST_CHECK_EQUAL(result_4->annotations & (TableParameters::AnnotationsType::Distance |
+                                               TableParameters::AnnotationsType::Duration),
+                      true);
+    CHECK_EQUAL_RANGE(reference_4.sources, result_4->sources);
+    CHECK_EQUAL_RANGE(reference_4.destinations, result_4->destinations);
+
+    TableParameters reference_5{};
+    reference_5.coordinates = coords_1;
+    auto result_5 = parseParameters<TableParameters>(
+        "1,2;3,4?sources=all&destinations=all&annotations=duration");
+    BOOST_CHECK(result_5);
+    BOOST_CHECK_EQUAL(result_5->annotations & TableParameters::AnnotationsType::Duration, true);
+    CHECK_EQUAL_RANGE(reference_5.sources, result_5->sources);
+    CHECK_EQUAL_RANGE(reference_5.destinations, result_5->destinations);
+
+    TableParameters reference_6{};
+    reference_6.coordinates = coords_1;
+    auto result_6 = parseParameters<TableParameters>(
+        "1,2;3,4?sources=all&destinations=all&annotations=distance");
+    BOOST_CHECK(result_6);
+    BOOST_CHECK_EQUAL(result_6->annotations & TableParameters::AnnotationsType::Distance, true);
+    CHECK_EQUAL_RANGE(reference_6.sources, result_6->sources);
+    CHECK_EQUAL_RANGE(reference_6.destinations, result_6->destinations);
+
+    TableParameters reference_7{};
+    reference_7.coordinates = coords_1;
+    auto result_7 = parseParameters<TableParameters>("1,2;3,4?annotations=distance");
+    BOOST_CHECK(result_7);
+    BOOST_CHECK_EQUAL(result_7->annotations & TableParameters::AnnotationsType::Distance, true);
+    CHECK_EQUAL_RANGE(reference_7.sources, result_7->sources);
+    CHECK_EQUAL_RANGE(reference_7.destinations, result_7->destinations);
 }
 
 BOOST_AUTO_TEST_CASE(valid_match_urls)
diff --git a/unit_tests/util/packed_vector.cpp b/unit_tests/util/packed_vector.cpp
index 56a66f1b23b..e8d55d9c228 100644
--- a/unit_tests/util/packed_vector.cpp
+++ b/unit_tests/util/packed_vector.cpp
@@ -220,6 +220,7 @@ BOOST_AUTO_TEST_CASE(packed_weights_container_with_type_erasure)
 
     auto forward = boost::make_iterator_range(vector.begin() + 1, vector.begin() + 6);
     auto forward_any = WeightsAnyRange(forward.begin(), forward.end());
+
     CHECK_EQUAL_RANGE(forward, 1, 2, 3, 4, 5);
     CHECK_EQUAL_RANGE(forward_any, 1, 2, 3, 4, 5);
 
@@ -243,11 +244,13 @@ BOOST_AUTO_TEST_CASE(packed_weights_view_with_type_erasure)
 
     auto forward = boost::make_iterator_range(view.begin() + 1, view.begin() + 4);
     auto forward_any = WeightsAnyRange(forward.begin(), forward.end());
+
     CHECK_EQUAL_RANGE(forward, 1, 2, 3);
     CHECK_EQUAL_RANGE(forward_any, 1, 2, 3);
 
     auto reverse = boost::adaptors::reverse(forward);
     auto reverse_any = WeightsAnyRange(reverse);
+
     CHECK_EQUAL_RANGE(reverse, 3, 2, 1);
     CHECK_EQUAL_RANGE(reverse_any, 3, 2, 1);
 }